back to Claude Sonnet 3.5 - Fill-in summary

Claude Sonnet 3.5 - Fill-in: babel

Pytest Summary for test tests

status	count
failed	1244
passed	21
skipped	1
total	1266
collected	1266

Failed pytests:

test_core.py::test_locale_provides_access_to_cldr_locale_data

test_core.py::test_locale_provides_access_to_cldr_locale_data

def test_locale_provides_access_to_cldr_locale_data():
        locale = Locale('en', 'US')
>       assert locale.display_name == 'English (United States)'
E       AssertionError: assert None == 'English (United States)'
E        +  where None = Locale('en', territory='US').display_name

tests/test_core.py:21: AssertionError

test_core.py::test_locale_repr

test_core.py::test_locale_repr

def test_locale_repr():
        assert repr(Locale('en', 'US')) == "Locale('en', territory='US')"
        assert (repr(Locale('de', 'DE')) == "Locale('de', territory='DE')")
>       assert (repr(Locale('zh', 'CN', script='Hans')) == "Locale('zh', territory='CN', script='Hans')")

tests/test_core.py:28: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Locale('zh', territory='CN', script='Hans'), language = 'zh'
territory = 'CN', script = 'Hans', variant = None, modifier = None

    def __init__(self, language: str, territory: (str | None)=None, script:
        (str | None)=None, variant: (str | None)=None, modifier: (str |
        None)=None) ->None:
        """Initialize the locale object from the given identifier components.

        >>> locale = Locale('en', 'US')
        >>> locale.language
        'en'
        >>> locale.territory
        'US'

        :param language: the language code
        :param territory: the territory (country or region) code
        :param script: the script code
        :param variant: the variant code
        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        """
        self.language = language
        self.territory = territory
        self.script = script
        self.variant = variant
        self.modifier = modifier
        self.__data: localedata.LocaleDataDict | None = None
        identifier = str(self)
        identifier_without_modifier = identifier.partition('@')[0]
        if not localedata.exists(identifier_without_modifier):
>           raise UnknownLocaleError(identifier)
E           babel.core.UnknownLocaleError: unknown locale 'zh_CN_Hans'

babel/core.py:159: UnknownLocaleError

test_core.py::test_can_return_default_locale

test_core.py::test_can_return_default_locale

os_environ = {'BLIS_NUM_THREADS': '1', 'CFLAGS': '-g0', 'HOME': '/root', 'LC_CTYPE': 'C.UTF-8', ...}

    def test_can_return_default_locale(os_environ):
        os_environ['LC_MESSAGES'] = 'fr_FR.UTF-8'
>       assert Locale('fr', 'FR') == Locale.default('LC_MESSAGES')

tests/test_core.py:47: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/core.py:184: in default
    return cls.parse(locale_string)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_default

test_core.py::TestLocaleClass::test_default

self = 
os_environ = {'BLIS_NUM_THREADS': '1', 'CFLAGS': '-g0', 'HOME': '/root', 'LANG': 'fr_FR.UTF-8', ...}

    def test_default(self, os_environ):
        for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
            os_environ[name] = ''
        os_environ['LANG'] = 'fr_FR.UTF-8'
>       default = Locale.default('LC_MESSAGES')

tests/test_core.py:83: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/core.py:184: in default
    return cls.parse(locale_string)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_negotiate

test_core.py::TestLocaleClass::test_negotiate

self = 

    def test_negotiate(self):
>       de_DE = Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])

tests/test_core.py:87: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/core.py:212: in negotiate
    return cls.parse(locale_identifier)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_de', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_negotiate_custom_separator

test_core.py::TestLocaleClass::test_negotiate_custom_separator

self = 

    def test_negotiate_custom_separator(self):
>       de_DE = Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')

tests/test_core.py:95: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/core.py:212: in negotiate
    return cls.parse(locale_identifier)
babel/core.py:276: in parse
    parts = parse_locale(identifier, sep)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

identifier = 'de-de', sep = '_'

    def parse_locale(identifier: str, sep: str='_') ->(tuple[str, str | None,
        str | None, str | None] | tuple[str, str | None, str | None, str | None,
        str | None]):
        """Parse a locale identifier into a tuple of the form ``(language,
        territory, script, variant, modifier)``.

        >>> parse_locale('zh_CN')
        ('zh', 'CN', None, None)
        >>> parse_locale('zh_Hans_CN')
        ('zh', 'CN', 'Hans', None)
        >>> parse_locale('ca_es_valencia')
        ('ca', 'ES', None, 'VALENCIA')
        >>> parse_locale('en_150')
        ('en', '150', None, None)
        >>> parse_locale('en_us_posix')
        ('en', 'US', None, 'POSIX')
        >>> parse_locale('it_IT@euro')
        ('it', 'IT', None, None, 'euro')
        >>> parse_locale('it_IT@custom')
        ('it', 'IT', None, None, 'custom')
        >>> parse_locale('it_IT@')
        ('it', 'IT', None, None)

        The default component separator is "_", but a different separator can be
        specified using the `sep` parameter.

        The optional modifier is always separated with "@" and at the end:

        >>> parse_locale('zh-CN', sep='-')
        ('zh', 'CN', None, None)
        >>> parse_locale('zh-CN@custom', sep='-')
        ('zh', 'CN', None, None, 'custom')

        If the identifier cannot be parsed into a locale, a `ValueError` exception
        is raised:

        >>> parse_locale('not_a_LOCALE_String')
        Traceback (most recent call last):
          ...
        ValueError: 'not_a_LOCALE_String' is not a valid locale identifier

        Encoding information is removed from the identifier, while modifiers are
        kept:

        >>> parse_locale('en_US.UTF-8')
        ('en', 'US', None, None)
        >>> parse_locale('de_DE.iso885915@euro')
        ('de', 'DE', None, None, 'euro')

        See :rfc:`4646` for more information.

        :param identifier: the locale identifier string
        :param sep: character that separates the different components of the locale
                    identifier
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        """
        if '@' in identifier:
            identifier, modifier = identifier.split('@', 1)
        else:
            modifier = None

        parts = identifier.split(sep)
        lang = parts.pop(0).lower()
        if not lang.isalpha():
>           raise ValueError(f"'{identifier}' is not a valid locale identifier")
E           ValueError: 'de-de' is not a valid locale identifier

babel/core.py:1094: ValueError

test_core.py::TestLocaleClass::test_parse

test_core.py::TestLocaleClass::test_parse

self = 

    def test_parse(self):
>       locale = Locale.parse('de-DE', sep='-')

tests/test_core.py:99: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de-DE', sep = '-'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_parse_likely_subtags

test_core.py::TestLocaleClass::test_parse_likely_subtags

self = 

    def test_parse_likely_subtags(self):
>       locale = Locale.parse('zh-TW', sep='-')

tests/test_core.py:106: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh-TW', sep = '-'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_get_display_name

test_core.py::TestLocaleClass::test_get_display_name

self = 

    def test_get_display_name(self):
>       zh_CN = Locale('zh', 'CN', script='Hans')

tests/test_core.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Locale('zh', territory='CN', script='Hans'), language = 'zh'
territory = 'CN', script = 'Hans', variant = None, modifier = None

    def __init__(self, language: str, territory: (str | None)=None, script:
        (str | None)=None, variant: (str | None)=None, modifier: (str |
        None)=None) ->None:
        """Initialize the locale object from the given identifier components.

        >>> locale = Locale('en', 'US')
        >>> locale.language
        'en'
        >>> locale.territory
        'US'

        :param language: the language code
        :param territory: the territory (country or region) code
        :param script: the script code
        :param variant: the variant code
        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        """
        self.language = language
        self.territory = territory
        self.script = script
        self.variant = variant
        self.modifier = modifier
        self.__data: localedata.LocaleDataDict | None = None
        identifier = str(self)
        identifier_without_modifier = identifier.partition('@')[0]
        if not localedata.exists(identifier_without_modifier):
>           raise UnknownLocaleError(identifier)
E           babel.core.UnknownLocaleError: unknown locale 'zh_CN_Hans'

babel/core.py:159: UnknownLocaleError

test_core.py::TestLocaleClass::test_display_name_property

test_core.py::TestLocaleClass::test_display_name_property

self = 

    def test_display_name_property(self):
>       assert Locale('en').display_name == 'English'
E       AssertionError: assert None == 'English'
E        +  where None = Locale('en').display_name
E        +    where Locale('en') = Locale('en')

tests/test_core.py:135: AssertionError

test_core.py::TestLocaleClass::test_english_name_property

test_core.py::TestLocaleClass::test_english_name_property

self = 

    def test_english_name_property(self):
>       assert Locale('de').english_name == 'German'
E       AssertionError: assert None == 'German'
E        +  where None = Locale('de').english_name
E        +    where Locale('de') = Locale('de')

tests/test_core.py:140: AssertionError

test_core.py::TestLocaleClass::test_languages_property

test_core.py::TestLocaleClass::test_languages_property

self = 

    def test_languages_property(self):
>       assert Locale('de', 'DE').languages['ja'] == 'Japanisch'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:144: TypeError

test_core.py::TestLocaleClass::test_scripts_property

test_core.py::TestLocaleClass::test_scripts_property

self = 

    def test_scripts_property(self):
>       assert Locale('en', 'US').scripts['Hira'] == 'Hiragana'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:147: TypeError

test_core.py::TestLocaleClass::test_territories_property

test_core.py::TestLocaleClass::test_territories_property

self = 

    def test_territories_property(self):
>       assert Locale('es', 'CO').territories['DE'] == 'Alemania'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:150: TypeError

test_core.py::TestLocaleClass::test_variants_property

test_core.py::TestLocaleClass::test_variants_property

self = 

    def test_variants_property(self):
>       assert (Locale('de', 'DE').variants['1901'] ==
                'Alte deutsche Rechtschreibung')
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:153: TypeError

test_core.py::TestLocaleClass::test_currencies_property

test_core.py::TestLocaleClass::test_currencies_property

self = 

    def test_currencies_property(self):
>       assert Locale('en').currencies['COP'] == 'Colombian Peso'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:157: TypeError

test_core.py::TestLocaleClass::test_currency_symbols_property

test_core.py::TestLocaleClass::test_currency_symbols_property

self = 

    def test_currency_symbols_property(self):
>       assert Locale('en', 'US').currency_symbols['USD'] == '$'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:161: TypeError

test_core.py::TestLocaleClass::test_number_symbols_property

test_core.py::TestLocaleClass::test_number_symbols_property

self = 

    def test_number_symbols_property(self):
>       assert Locale('fr', 'FR').number_symbols["latn"]['decimal'] == ','
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:165: TypeError

test_core.py::TestLocaleClass::test_other_numbering_systems_property

test_core.py::TestLocaleClass::test_other_numbering_systems_property

self = 

    def test_other_numbering_systems_property(self):
>       assert Locale('fr', 'FR').other_numbering_systems['native'] == 'latn'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:170: TypeError

test_core.py::TestLocaleClass::test_default_numbering_systems_property

test_core.py::TestLocaleClass::test_default_numbering_systems_property

self = 

    def test_default_numbering_systems_property(self):
>       assert Locale('en', 'GB').default_numbering_system == 'latn'
E       AssertionError: assert None == 'latn'
E        +  where None = Locale('en', territory='GB').default_numbering_system
E        +    where Locale('en', territory='GB') = Locale('en', 'GB')

tests/test_core.py:177: AssertionError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[brx]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[brx]

self = 
locale = 'brx'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'brx', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GN]

self = 
locale = 'ff_Latn_GN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_GN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sms_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sms_FI]

self = 
locale = 'sms_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sms_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mua]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mua]

self = 
locale = 'mua'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mua', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[id]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[id]

self = , locale = 'id'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'id', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[br]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[br]

self = , locale = 'br'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'br', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[blt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[blt]

self = 
locale = 'blt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'blt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_KW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_KW]

self = 
locale = 'ar_KW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_KW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg_MM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg_MM]

self = 
locale = 'rhg_Rohg_MM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rhg_Rohg_MM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Deva]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Deva]

self = 
locale = 'sd_Deva'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sd_Deva', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rm_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rm_CH]

self = 
locale = 'rm_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rm_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj]

self = 
locale = 'hnj'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hnj', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn_TH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn_TH]

self = 
locale = 'shn_TH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shn_TH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ku]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ku]

self = , locale = 'ku'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ku', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ny]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ny]

self = , locale = 'ny'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ny', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar]

self = , locale = 'ar'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa_AF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa_AF]

self = 
locale = 'fa_AF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fa_AF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ce_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ce_RU]

self = 
locale = 'ce_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ce_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp]

self = 
locale = 'ccp'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ccp', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SS]

self = 
locale = 'ar_SS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_SS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KN]

self = 
locale = 'en_KN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_KN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[et_EE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[et_EE]

self = 
locale = 'et_EE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'et_EE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[an_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[an_ES]

self = 
locale = 'an_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'an_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[arn_CL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[arn_CL]

self = 
locale = 'arn_CL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'arn_CL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GN]

self = 
locale = 'ff_Adlm_GN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_GN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[to]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[to]

self = , locale = 'to'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'to', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_IN]

self = 
locale = 'ta_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ta_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fil_PH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fil_PH]

self = 
locale = 'fil_PH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fil_PH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Dsrt_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Dsrt_US]

self = 
locale = 'en_Dsrt_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_Dsrt_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TO]

self = 
locale = 'en_TO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_JM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_JM]

self = 
locale = 'en_JM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_JM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jgo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jgo]

self = 
locale = 'jgo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jgo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lag]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lag]

self = 
locale = 'lag'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lag', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mzn_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mzn_IR]

self = 
locale = 'mzn_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mzn_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sc]

self = , locale = 'sc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksf]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksf]

self = 
locale = 'ksf'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksf', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om]

self = , locale = 'om'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'om', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Cyrl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Cyrl]

self = 
locale = 'uz_Cyrl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Cyrl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms]

self = , locale = 'ms'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PK]

self = 
locale = 'en_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur_IN]

self = 
locale = 'ur_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ur_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BF]

self = 
locale = 'fr_BF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_BF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jmc_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jmc_TZ]

self = 
locale = 'jmc_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jmc_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr]

self = , locale = 'tr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[asa_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[asa_TZ]

self = 
locale = 'asa_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'asa_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu]

self = , locale = 'qu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'qu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CH]

self = 
locale = 'en_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cch]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cch]

self = 
locale = 'cch'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cch', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rwk_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rwk_TZ]

self = 
locale = 'rwk_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rwk_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SD]

self = 
locale = 'ar_SD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_SD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wal]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wal]

self = 
locale = 'wal'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wal', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_US]

self = 
locale = 'en_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[raj]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[raj]

self = 
locale = 'raj'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'raj', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hant]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hant]

self = 
locale = 'yue_Hant'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yue_Hant', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_NO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_NO]

self = 
locale = 'se_NO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'se_NO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_AO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_AO]

self = 
locale = 'ln_AO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ln_AO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_LU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_LU]

self = 
locale = 'fr_LU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_LU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_BA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_BA]

self = 
locale = 'sr_Cyrl_BA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Cyrl_BA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_MA]

self = 
locale = 'ar_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez_ER]

self = 
locale = 'gez_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gez_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cs]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cs]

self = , locale = 'cs'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cs', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_GW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_GW]

self = 
locale = 'pt_GW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_GW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo_IN]

self = 
locale = 'bo_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bo_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZM]

self = 
locale = 'en_ZM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_ZM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mt_MT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mt_MT]

self = 
locale = 'mt_MT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mt_MT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CM]

self = 
locale = 'en_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[seh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[seh]

self = 
locale = 'seh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'seh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl]

self = 
locale = 'sr_Cyrl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Cyrl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dav]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dav]

self = 
locale = 'dav'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dav', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat]

self = 
locale = 'sat'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sat', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr]

self = , locale = 'fr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_MY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_MY]

self = 
locale = 'ms_MY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_MY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SE]

self = 
locale = 'en_SE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nv]

self = , locale = 'nv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Latn_AZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Latn_AZ]

self = 
locale = 'az_Latn_AZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Latn_AZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PR]

self = 
locale = 'en_PR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xog_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xog_UG]

self = 
locale = 'xog_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'xog_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dje_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dje_NE]

self = 
locale = 'dje_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dje_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DM]

self = 
locale = 'en_DM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_DM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_ES]

self = 
locale = 'es_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[apc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[apc]

self = 
locale = 'apc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'apc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sl]

self = , locale = 'sl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dyo_SN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dyo_SN]

self = 
locale = 'dyo_SN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dyo_SN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_HK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_HK]

self = 
locale = 'en_HK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_HK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[szl_PL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[szl_PL]

self = 
locale = 'szl_PL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'szl_PL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Latn_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Latn_LR]

self = 
locale = 'vai_Latn_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vai_Latn_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma]

self = 
locale = 'sma'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sma', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksb]

self = 
locale = 'ksb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ken]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ken]

self = 
locale = 'ken'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ken', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AS]

self = 
locale = 'en_AS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mdf]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mdf]

self = 
locale = 'mdf'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mdf', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_HK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_HK]

self = 
locale = 'zh_Hans_HK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hans_HK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj_NO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj_NO]

self = 
locale = 'smj_NO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'smj_NO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[apc_SY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[apc_SY]

self = 
locale = 'apc_SY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'apc_SY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kkj_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kkj_CM]

self = 
locale = 'kkj_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kkj_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ii_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ii_CN]

self = 
locale = 'ii_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ii_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_VE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_VE]

self = 
locale = 'es_VE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_VE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt]

self = , locale = 'pt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zu_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zu_ZA]

self = 
locale = 'zu_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zu_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[byn_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[byn_ER]

self = 
locale = 'byn_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'byn_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su_Latn]

self = 
locale = 'su_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'su_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SC]

self = 
locale = 'fr_SC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_SC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ak]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ak]

self = , locale = 'ak'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ak', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_AT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_AT]

self = 
locale = 'de_AT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_AT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb_IR]

self = 
locale = 'ckb_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ckb_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_AD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_AD]

self = 
locale = 'ca_AD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_AD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_NL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_NL]

self = 
locale = 'nl_NL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_NL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_SG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_SG]

self = 
locale = 'ta_SG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ta_SG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Beng_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Beng_IN]

self = 
locale = 'mni_Beng_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mni_Beng_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_IQ]

self = 
locale = 'az_Arab_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Arab_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg]

self = 
locale = 'rhg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rhg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CK]

self = 
locale = 'en_CK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ast]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ast]

self = 
locale = 'ast'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ast', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[he_IL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[he_IL]

self = 
locale = 'he_IL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'he_IL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_LB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_LB]

self = 
locale = 'ar_LB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_LB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant]

self = 
locale = 'zh_Hant'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hant', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss_ZA]

self = 
locale = 'ss_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ss_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Vaii_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Vaii_LR]

self = 
locale = 'vai_Vaii_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vai_Vaii_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fi]

self = , locale = 'fi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dua_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dua_CM]

self = 
locale = 'dua_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dua_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_CH]

self = 
locale = 'pt_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_Nkoo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_Nkoo]

self = 
locale = 'bm_Nkoo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bm_Nkoo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om_ET]

self = 
locale = 'om_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'om_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su_Latn_ID]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su_Latn_ID]

self = 
locale = 'su_Latn_ID'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'su_Latn_ID', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sa]

self = , locale = 'sa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_NI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_NI]

self = 
locale = 'es_NI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_NI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af_ZA]

self = 
locale = 'af_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'af_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smn_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smn_FI]

self = 
locale = 'smn_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'smn_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pl_PL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pl_PL]

self = 
locale = 'pl_PL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pl_PL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_CM]

self = 
locale = 'ff_Adlm_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bg_BG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bg_BG]

self = 
locale = 'bg_BG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bg_BG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_BF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_BF]

self = 
locale = 'ff_Adlm_BF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_BF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GW]

self = 
locale = 'ff_Adlm_GW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_GW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_NG]

self = 
locale = 'ff_Adlm_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_JO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_JO]

self = 
locale = 'ar_JO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_JO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[la_VA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[la_VA]

self = 
locale = 'la_VA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'la_VA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo]

self = 
locale = 'teo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'teo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_ET]

self = 
locale = 'aa_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'aa_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_TL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_TL]

self = 
locale = 'pt_TL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_TL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bas_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bas_CM]

self = 
locale = 'bas_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bas_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh_IR]

self = 
locale = 'sdh_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sdh_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zgh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zgh]

self = 
locale = 'zgh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zgh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ast_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ast_ES]

self = 
locale = 'ast_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ast_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_XK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_XK]

self = 
locale = 'sr_Latn_XK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Latn_XK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gv]

self = , locale = 'gv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gu]

self = , locale = 'gu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pcm_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pcm_NG]

self = 
locale = 'pcm_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pcm_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff]

self = , locale = 'ff'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rw]

self = , locale = 'rw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lu_CD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lu_CD]

self = 
locale = 'lu_CD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lu_CD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gv_IM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gv_IM]

self = 
locale = 'gv_IM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gv_IM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[co_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[co_FR]

self = 
locale = 'co_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'co_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el]

self = , locale = 'el'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'el', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Arab]

self = 
locale = 'sd_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sd_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KE]

self = 
locale = 'en_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kgp]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kgp]

self = 
locale = 'kgp'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kgp', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os]

self = , locale = 'os'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'os', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se]

self = , locale = 'se'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'se', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bas]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bas]

self = 
locale = 'bas'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bas', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sid_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sid_ET]

self = 
locale = 'sid_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sid_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tk_TM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tk_TM]

self = 
locale = 'tk_TM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tk_TM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BZ]

self = 
locale = 'en_BZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GA]

self = 
locale = 'fr_GA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_GA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_AR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_AR]

self = 
locale = 'es_AR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_AR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ky]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ky]

self = , locale = 'ky'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ky', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NA]

self = 
locale = 'en_NA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jgo_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jgo_CM]

self = 
locale = 'jgo_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jgo_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_Latn]

self = 
locale = 'hi_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hi_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[prg_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[prg_001]

self = 
locale = 'prg_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'prg_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dsb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dsb]

self = 
locale = 'dsb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dsb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Arab]

self = 
locale = 'pa_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pa_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc_IQ]

self = 
locale = 'lrc_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lrc_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CM]

self = 
locale = 'fr_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az]

self = , locale = 'az'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro_MD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro_MD]

self = 
locale = 'ro_MD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ro_MD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_LR]

self = 
locale = 'ff_Adlm_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nyn_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nyn_UG]

self = 
locale = 'nyn_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nyn_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_001]

self = 
locale = 'en_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lv]

self = , locale = 'lv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue]

self = 
locale = 'yue'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yue', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_US_POSIX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_US_POSIX]

self = 
locale = 'en_US_POSIX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_US_POSIX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bss_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bss_CM]

self = 
locale = 'bss_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bss_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nqo_GN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nqo_GN]

self = 
locale = 'nqo_GN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nqo_GN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GF]

self = 
locale = 'fr_GF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_GF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm]

self = , locale = 'bm'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bm', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MW]

self = 
locale = 'en_MW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LS]

self = 
locale = 'en_LS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_LS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st_LS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st_LS]

self = 
locale = 'st_LS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'st_LS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[to_TO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[to_TO]

self = 
locale = 'to_TO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'to_TO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NZ]

self = 
locale = 'en_NZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[io]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[io]

self = , locale = 'io'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'io', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gaa_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gaa_GH]

self = 
locale = 'gaa_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gaa_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AU]

self = 
locale = 'en_AU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nso]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nso]

self = 
locale = 'nso'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nso', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MY]

self = 
locale = 'en_MY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko_KP]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko_KP]

self = 
locale = 'ko_KP'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ko_KP', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_AW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_AW]

self = 
locale = 'nl_AW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_AW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_NG]

self = 
locale = 'ha_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bez]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bez]

self = 
locale = 'bez'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bez', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lkt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lkt]

self = 
locale = 'lkt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lkt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hu]

self = , locale = 'hu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn]

self = , locale = 'tn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Guru]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Guru]

self = 
locale = 'pa_Guru'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pa_Guru', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Latn_UZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Latn_UZ]

self = 
locale = 'uz_Latn_UZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Latn_UZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kam_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kam_KE]

self = 
locale = 'kam_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kam_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wbp]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wbp]

self = 
locale = 'wbp'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wbp', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_CW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_CW]

self = 
locale = 'nl_CW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_CW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SO]

self = 
locale = 'ar_SO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_SO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LC]

self = 
locale = 'en_LC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_LC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yi]

self = , locale = 'yi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_EH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_EH]

self = 
locale = 'ar_EH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_EH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TG]

self = 
locale = 'fr_TG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_TG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hant_HK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hant_HK]

self = 
locale = 'yue_Hant_HK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yue_Hant_HK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nd_ZW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nd_ZW]

self = 
locale = 'nd_ZW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nd_ZW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MH]

self = 
locale = 'en_MH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GM]

self = 
locale = 'ff_Adlm_GM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_GM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KI]

self = 
locale = 'en_KI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_KI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[io_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[io_001]

self = 
locale = 'io_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'io_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Shaw_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Shaw_GB]

self = 
locale = 'en_Shaw_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_Shaw_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NL]

self = 
locale = 'en_NL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_419]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_419]

self = 
locale = 'es_419'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_419', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cu_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cu_RU]

self = 
locale = 'cu_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cu_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nnh_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nnh_CM]

self = 
locale = 'nnh_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nnh_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jbo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jbo]

self = 
locale = 'jbo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jbo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ce]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ce]

self = , locale = 'ce'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ce', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_SO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_SO]

self = 
locale = 'so_SO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'so_SO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[frr_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[frr_DE]

self = 
locale = 'frr_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'frr_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nr]

self = , locale = 'nr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jv_ID]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jv_ID]

self = 
locale = 'jv_ID'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jv_ID', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uk_UA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uk_UA]

self = 
locale = 'uk_UA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uk_UA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo]

self = , locale = 'bo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh]

self = 
locale = 'sdh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sdh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MS]

self = 
locale = 'en_MS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mg]

self = , locale = 'mg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dz]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dz]

self = , locale = 'dz'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dz', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ki_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ki_KE]

self = 
locale = 'ki_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ki_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_CH]

self = 
locale = 'gsw_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gsw_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gd_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gd_GB]

self = 
locale = 'gd_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gd_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[arn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[arn]

self = 
locale = 'arn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'arn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sbp]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sbp]

self = 
locale = 'sbp'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sbp', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cch_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cch_NG]

self = 
locale = 'cch_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cch_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nus]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nus]

self = 
locale = 'nus'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nus', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa_IR]

self = 
locale = 'fa_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fa_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wa]

self = , locale = 'wa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Cyrl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Cyrl]

self = 
locale = 'az_Cyrl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Cyrl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgh]

self = 
locale = 'mgh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mgh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SN]

self = 
locale = 'fr_SN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_SN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MV]

self = 
locale = 'en_MV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_VU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_VU]

self = 
locale = 'fr_VU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_VU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dsb_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dsb_DE]

self = 
locale = 'dsb_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dsb_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[agq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[agq]

self = 
locale = 'agq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'agq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mus]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mus]

self = 
locale = 'mus'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mus', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fi_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fi_FI]

self = 
locale = 'fi_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fi_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Beng]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Beng]

self = 
locale = 'mni_Beng'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mni_Beng', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cv]

self = , locale = 'cv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_CA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_CA]

self = 
locale = 'iu_CA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'iu_CA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luy_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luy_KE]

self = 
locale = 'luy_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'luy_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_JE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_JE]

self = 
locale = 'en_JE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_JE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_MR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_MR]

self = 
locale = 'ff_Adlm_MR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_MR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr_SY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr_SY]

self = 
locale = 'syr_SY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'syr_SY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BS]

self = 
locale = 'en_BS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[naq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[naq]

self = 
locale = 'naq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'naq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Tfng]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Tfng]

self = 
locale = 'shi_Tfng'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shi_Tfng', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[osa_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[osa_US]

self = 
locale = 'osa_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'osa_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc_IR]

self = 
locale = 'lrc_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lrc_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mr_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mr_IN]

self = 
locale = 'mr_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mr_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_IT]

self = 
locale = 'de_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lg_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lg_UG]

self = 
locale = 'lg_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lg_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wo]

self = , locale = 'wo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CD]

self = 
locale = 'ln_CD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ln_CD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru]

self = , locale = 'ru'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_MO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_MO]

self = 
locale = 'zh_Hans_MO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hans_MO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mai]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mai]

self = 
locale = 'mai'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mai', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Latn]

self = 
locale = 'bal_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bal_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GM]

self = 
locale = 'en_GM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ve_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ve_ZA]

self = 
locale = 've_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 've_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_RW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_RW]

self = 
locale = 'en_RW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_RW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be_BY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be_BY]

self = 
locale = 'be_BY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'be_BY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_LY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_LY]

self = 
locale = 'ar_LY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_LY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[as_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[as_IN]

self = 
locale = 'as_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'as_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PY]

self = 
locale = 'es_PY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_PY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab]

self = 
locale = 'ha_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp_IN]

self = 
locale = 'ccp_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ccp_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zu]

self = , locale = 'zu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_HT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_HT]

self = 
locale = 'fr_HT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_HT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MT]

self = 
locale = 'en_MT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kea]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kea]

self = 
locale = 'kea'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kea', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_RE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_RE]

self = 
locale = 'fr_RE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_RE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tig]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tig]

self = 
locale = 'tig'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tig', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fy_NL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fy_NL]

self = 
locale = 'fy_NL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fy_NL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CO]

self = 
locale = 'es_CO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_CO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mg_MG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mg_MG]

self = 
locale = 'mg_MG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mg_MG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ssy_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ssy_ER]

self = 
locale = 'ssy_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ssy_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ebu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ebu]

self = 
locale = 'ebu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ebu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma_NO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma_NO]

self = 
locale = 'sma_NO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sma_NO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luy]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luy]

self = 
locale = 'luy'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'luy', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tg_TJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tg_TJ]

self = 
locale = 'tg_TJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tg_TJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cgg_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cgg_UG]

self = 
locale = 'cgg_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cgg_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_Latn]

self = 
locale = 'iu_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'iu_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[su]

self = , locale = 'su'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'su', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Arab_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Arab_IN]

self = 
locale = 'ks_Arab_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ks_Arab_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_SN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_SN]

self = 
locale = 'ff_Latn_SN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_SN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kok_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kok_IN]

self = 
locale = 'kok_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kok_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mfe]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mfe]

self = 
locale = 'mfe'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mfe', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_EC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_EC]

self = 
locale = 'qu_EC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'qu_EC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[la]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[la]

self = , locale = 'la'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'la', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb_IQ]

self = 
locale = 'ckb_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ckb_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Olck]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Olck]

self = 
locale = 'sat_Olck'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sat_Olck', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd]

self = , locale = 'sd'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sd', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_KG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_KG]

self = 
locale = 'ru_KG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_KG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_RW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_RW]

self = 
locale = 'fr_RW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_RW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tk]

self = , locale = 'tk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uk]

self = , locale = 'uk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_LU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_LU]

self = 
locale = 'de_LU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_LU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vun_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vun_TZ]

self = 
locale = 'vun_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vun_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu]

self = , locale = 'iu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'iu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_OM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_OM]

self = 
locale = 'bgn_OM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn_OM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_LI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_LI]

self = 
locale = 'gsw_LI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gsw_LI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sa_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sa_IN]

self = 
locale = 'sa_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sa_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DG]

self = 
locale = 'en_DG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_DG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de]

self = , locale = 'de'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_NE]

self = 
locale = 'fr_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[is]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[is]

self = , locale = 'is'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'is', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_NE]

self = 
locale = 'ff_Latn_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti]

self = , locale = 'ti'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ti', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds_DE]

self = 
locale = 'nds_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nds_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bo_CN]

self = 
locale = 'bo_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bo_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_DJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_DJ]

self = 
locale = 'so_DJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'so_DJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mi_NZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mi_NZ]

self = 
locale = 'mi_NZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mi_NZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sid]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sid]

self = 
locale = 'sid'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sid', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sms]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sms]

self = 
locale = 'sms'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sms', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_DJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_DJ]

self = 
locale = 'fr_DJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_DJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kea_CV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kea_CV]

self = 
locale = 'kea_CV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kea_CV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo_DK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo_DK]

self = 
locale = 'fo_DK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fo_DK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dyo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dyo]

self = 
locale = 'dyo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dyo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nmg_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nmg_CM]

self = 
locale = 'nmg_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nmg_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bho]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bho]

self = 
locale = 'bho'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bho', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_ID]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_ID]

self = 
locale = 'ms_ID'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_ID', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_BQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_BQ]

self = 
locale = 'nl_BQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_BQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CU]

self = 
locale = 'es_CU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_CU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ky_KG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ky_KG]

self = 
locale = 'ky_KG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ky_KG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ka_GE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ka_GE]

self = 
locale = 'ka_GE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ka_GE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lv_LV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lv_LV]

self = 
locale = 'lv_LV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lv_LV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sk]

self = , locale = 'sk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st]

self = , locale = 'st'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'st', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kde]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kde]

self = 
locale = 'kde'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kde', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hsb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hsb]

self = 
locale = 'hsb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hsb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga_IE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga_IE]

self = 
locale = 'ga_IE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ga_IE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm]

self = 
locale = 'ff_Adlm'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bez_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bez_TZ]

self = 
locale = 'bez_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bez_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[co]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[co]

self = , locale = 'co'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'co', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Vaii]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Vaii]

self = 
locale = 'vai_Vaii'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vai_Vaii', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZW]

self = 
locale = 'en_ZW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_ZW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_ML]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_ML]

self = 
locale = 'fr_ML'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_ML', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MG]

self = 
locale = 'fr_MG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga]

self = , locale = 'ga'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ga', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SH]

self = 
locale = 'en_SH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ia_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ia_001]

self = 
locale = 'ia_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ia_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp_BD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ccp_BD]

self = 
locale = 'ccp_BD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ccp_BD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dv_MV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dv_MV]

self = 
locale = 'dv_MV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dv_MV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps]

self = , locale = 'ps'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ps', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os_RU]

self = 
locale = 'os_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'os_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sc_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sc_IT]

self = 
locale = 'sc_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sc_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Mtei]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Mtei]

self = 
locale = 'mni_Mtei'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mni_Mtei', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cad_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cad_US]

self = 
locale = 'cad_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cad_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo_KE]

self = 
locale = 'teo_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'teo_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc_ES]

self = 
locale = 'oc_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'oc_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DE]

self = 
locale = 'en_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sk_SK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sk_SK]

self = 
locale = 'sk_SK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sk_SK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[root]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[root]

self = 
locale = 'root'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'root', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[am_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[am_ET]

self = 
locale = 'am_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'am_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ug]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ug]

self = , locale = 'ug'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ug', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trw_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trw_PK]

self = 
locale = 'trw_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'trw_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jmc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jmc]

self = 
locale = 'jmc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jmc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[doi_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[doi_IN]

self = 
locale = 'doi_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'doi_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[frr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[frr]

self = 
locale = 'frr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'frr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gl]

self = , locale = 'gl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn]

self = 
locale = 'ff_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rw_RW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rw_RW]

self = 
locale = 'rw_RW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rw_RW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dv]

self = , locale = 'dv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[brx_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[brx_IN]

self = 
locale = 'brx_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'brx_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_CY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_CY]

self = 
locale = 'el_CY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'el_CY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh]

self = , locale = 'zh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trw]

self = 
locale = 'trw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'trw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ts_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ts_ZA]

self = 
locale = 'ts_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ts_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_AO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_AO]

self = 
locale = 'pt_AO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_AO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ssy]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ssy]

self = 
locale = 'ssy'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ssy', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_NE]

self = 
locale = 'ff_Adlm_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Arab]

self = 
locale = 'uz_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Arab_AF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Arab_AF]

self = 
locale = 'uz_Arab_AF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Arab_AF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_GH]

self = 
locale = 'ff_Adlm_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cgg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cgg]

self = 
locale = 'cgg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cgg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn_BW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn_BW]

self = 
locale = 'tn_BW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tn_BW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os_GE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[os_GE]

self = 
locale = 'os_GE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'os_GE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[km]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[km]

self = , locale = 'km'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'km', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lmo_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lmo_IT]

self = 
locale = 'lmo_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lmo_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ZA]

self = 
locale = 'en_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PG]

self = 
locale = 'en_PG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pis]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pis]

self = 
locale = 'pis'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pis', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CL]

self = 
locale = 'es_CL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_CL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Latn]

self = 
locale = 'shi_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shi_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BW]

self = 
locale = 'en_BW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CH]

self = 
locale = 'fr_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_POLYTON]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_POLYTON]

self = 
locale = 'el_POLYTON'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'el_POLYTON', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tt]

self = , locale = 'tt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_SL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_SL]

self = 
locale = 'ff_Adlm_SL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_SL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma_SE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sma_SE]

self = 
locale = 'sma_SE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sma_SE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GH]

self = 
locale = 'ff_Latn_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tok_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tok_001]

self = 
locale = 'tok_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tok_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[he]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[he]

self = , locale = 'he'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'he', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gn]

self = , locale = 'gn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bg]

self = , locale = 'bg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Latn_BA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Latn_BA]

self = 
locale = 'bs_Latn_BA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bs_Latn_BA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nso_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nso_ZA]

self = 
locale = 'nso_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nso_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vo]

self = , locale = 'vo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_SV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_SV]

self = 
locale = 'es_SV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_SV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_RU]

self = 
locale = 'ru_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_AE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_AE]

self = 
locale = 'bgn_AE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn_AE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_RS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_RS]

self = 
locale = 'sr_Cyrl_RS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Cyrl_RS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jbo_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jbo_001]

self = 
locale = 'jbo_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jbo_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nmg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nmg]

self = 
locale = 'nmg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nmg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq]

self = , locale = 'sq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab_SD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab_SD]

self = 
locale = 'ha_Arab_SD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_Arab_SD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_UA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_UA]

self = 
locale = 'ru_UA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_UA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ml_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ml_IN]

self = 
locale = 'ml_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ml_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl]

self = , locale = 'nl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_EG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_EG]

self = 
locale = 'ar_EG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_EG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw_FR]

self = 
locale = 'gsw_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gsw_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AE]

self = 
locale = 'en_AE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[teo_UG]

self = 
locale = 'teo_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'teo_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_ES_VALENCIA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_ES_VALENCIA]

self = 
locale = 'ca_ES_VALENCIA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_ES_VALENCIA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tok]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tok]

self = 
locale = 'tok'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tok', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CF]

self = 
locale = 'fr_CF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kw]

self = , locale = 'kw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lkt_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lkt_US]

self = 
locale = 'lkt_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lkt_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_YE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_YE]

self = 
locale = 'ar_YE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_YE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ken_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ken_CM]

self = 
locale = 'ken_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ken_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne]

self = , locale = 'ne'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ne', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Latn_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Latn_MA]

self = 
locale = 'shi_Latn_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shi_Latn_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ki]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ki]

self = , locale = 'ki'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ki', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_AE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_AE]

self = 
locale = 'ar_AE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_AE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_KM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_KM]

self = 
locale = 'ar_KM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_KM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[guz]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[guz]

self = 
locale = 'guz'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'guz', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_RS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_RS]

self = 
locale = 'sr_Latn_RS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Latn_RS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai_Latn]

self = 
locale = 'vai_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vai_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_BR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_BR]

self = 
locale = 'pt_BR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_BR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksh_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksh_DE]

self = 
locale = 'ksh_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksh_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yi_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yi_001]

self = 
locale = 'yi_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yi_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[quc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[quc]

self = 
locale = 'quc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'quc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kab_DZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kab_DZ]

self = 
locale = 'kab_DZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kab_DZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_EC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_EC]

self = 
locale = 'es_EC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_EC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa]

self = , locale = 'aa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'aa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VI]

self = 
locale = 'en_VI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_VI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PR]

self = 
locale = 'es_PR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_PR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CC]

self = 
locale = 'en_CC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kk]

self = , locale = 'kk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc_FR]

self = 
locale = 'oc_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'oc_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_FR]

self = 
locale = 'fr_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SA]

self = 
locale = 'ar_SA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_SA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_BR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_BR]

self = 
locale = 'yrl_BR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yrl_BR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tt_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tt_RU]

self = 
locale = 'tt_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tt_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PH]

self = 
locale = 'en_PH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn_MM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn_MM]

self = 
locale = 'shn_MM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shn_MM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_ML]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_ML]

self = 
locale = 'bm_ML'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bm_ML', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_DK]

self = 
locale = 'en_DK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_DK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BI]

self = 
locale = 'en_BI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee_GH]

self = 
locale = 'ee_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ee_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AI]

self = 
locale = 'en_AI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en]

self = , locale = 'en'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MA]

self = 
locale = 'fr_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_WF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_WF]

self = 
locale = 'fr_WF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_WF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_UM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_UM]

self = 
locale = 'en_UM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_UM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_MR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_MR]

self = 
locale = 'ar_MR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_MR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_LK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_LK]

self = 
locale = 'ta_LK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ta_LK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IO]

self = 
locale = 'en_IO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_IO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Dsrt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Dsrt]

self = 
locale = 'en_Dsrt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_Dsrt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ab]

self = , locale = 'ab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_AL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_AL]

self = 
locale = 'sq_AL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sq_AL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb]

self = , locale = 'nb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Latn_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Latn_PK]

self = 
locale = 'bal_Latn_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bal_Latn_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Cyrl_UZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Cyrl_UZ]

self = 
locale = 'uz_Cyrl_UZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Cyrl_UZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[asa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[asa]

self = 
locale = 'asa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'asa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NU]

self = 
locale = 'en_NU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it]

self = , locale = 'it'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'it', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ii]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ii]

self = , locale = 'ii'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ii', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_DE]

self = 
locale = 'de_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_GH]

self = 
locale = 'ha_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_GQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_GQ]

self = 
locale = 'es_GQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_GQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo_NG]

self = 
locale = 'yo_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yo_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Olck_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Olck_IN]

self = 
locale = 'sat_Olck_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sat_Olck_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sah]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sah]

self = 
locale = 'sah'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sah', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wae_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wae_CH]

self = 
locale = 'wae_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wae_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cy_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cy_GB]

self = 
locale = 'cy_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cy_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fur_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fur_IT]

self = 
locale = 'fur_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fur_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eu_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eu_ES]

self = 
locale = 'eu_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'eu_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kaj]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kaj]

self = 
locale = 'kaj'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kaj', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_ME]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_ME]

self = 
locale = 'sr_Cyrl_ME'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Cyrl_ME', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rm]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rm]

self = , locale = 'rm'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rm', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[te]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[te]

self = , locale = 'te'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'te', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap_CW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap_CW]

self = 
locale = 'pap_CW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pap_CW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Shaw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_Shaw]

self = 
locale = 'en_Shaw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_Shaw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_ME]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_ME]

self = 
locale = 'sr_Latn_ME'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Latn_ME', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_SY]

self = 
locale = 'fr_SY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_SY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez_ET]

self = 
locale = 'gez_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gez_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bem_ZM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bem_ZM]

self = 
locale = 'bem_ZM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bem_ZM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ba_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ba_RU]

self = 
locale = 'ba_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ba_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_BH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_BH]

self = 
locale = 'ar_BH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_BH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ckb]

self = 
locale = 'ckb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ckb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_Latn_CA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[iu_Latn_CA]

self = 
locale = 'iu_Latn_CA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'iu_Latn_CA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo_BJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo_BJ]

self = 
locale = 'yo_BJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yo_BJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab_BN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab_BN]

self = 
locale = 'ms_Arab_BN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_Arab_BN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hu_HU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hu_HU]

self = 
locale = 'hu_HU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hu_HU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TV]

self = 
locale = 'en_TV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn_BD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn_BD]

self = 
locale = 'bn_BD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bn_BD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[prg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[prg]

self = 
locale = 'prg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'prg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[am]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[am]

self = , locale = 'am'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'am', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj_SE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj_SE]

self = 
locale = 'smj_SE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'smj_SE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas]

self = 
locale = 'mas'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mas', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nv_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nv_US]

self = 
locale = 'nv_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nv_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr_BA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr_BA]

self = 
locale = 'hr_BA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hr_BA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_PT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_PT]

self = 
locale = 'pt_PT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_PT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pcm]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pcm]

self = 
locale = 'pcm'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pcm', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eo]

self = , locale = 'eo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'eo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mai_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mai_IN]

self = 
locale = 'mai_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mai_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dua]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dua]

self = 
locale = 'dua'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dua', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SI]

self = 
locale = 'en_SI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab_MY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab_MY]

self = 
locale = 'ms_Arab_MY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_Arab_MY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj_Hmnp_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj_Hmnp_US]

self = 
locale = 'hnj_Hmnp_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hnj_Hmnp_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_BO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_BO]

self = 
locale = 'qu_BO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'qu_BO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn]

self = , locale = 'mn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kde_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kde_TZ]

self = 
locale = 'kde_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kde_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cu]

self = , locale = 'cu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[khq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[khq]

self = 
locale = 'khq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'khq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_SN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Adlm_SN]

self = 
locale = 'ff_Adlm_SN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Adlm_SN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GB]

self = 
locale = 'en_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Cyrl_BA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Cyrl_BA]

self = 
locale = 'bs_Cyrl_BA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bs_Cyrl_BA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GN]

self = 
locale = 'fr_GN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_GN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hsb_DE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hsb_DE]

self = 
locale = 'hsb_DE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hsb_DE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TT]

self = 
locale = 'en_TT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BE]

self = 
locale = 'fr_BE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_BE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MC]

self = 
locale = 'fr_MC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[guz_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[guz_KE]

self = 
locale = 'guz_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'guz_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mk_MK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mk_MK]

self = 
locale = 'mk_MK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mk_MK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_XK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_XK]

self = 
locale = 'sq_XK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sq_XK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz]

self = , locale = 'uz'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_SE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_SE]

self = 
locale = 'se_SE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'se_SE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs]

self = , locale = 'bs'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bs', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong_CN]

self = 
locale = 'mn_Mong_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mn_Mong_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smn]

self = 
locale = 'smn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'smn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CG]

self = 
locale = 'ln_CG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ln_CG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[se_FI]

self = 
locale = 'se_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'se_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TZ]

self = 
locale = 'en_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_VE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_VE]

self = 
locale = 'yrl_VE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yrl_VE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rn]

self = , locale = 'rn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wbp_AU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wbp_AU]

self = 
locale = 'wbp_AU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wbp_AU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_GT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_GT]

self = 
locale = 'es_GT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_GT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ba]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ba]

self = , locale = 'ba'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ba', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sn]

self = , locale = 'sn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_DJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_DJ]

self = 
locale = 'aa_DJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'aa_DJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr]

self = 
locale = 'syr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'syr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans]

self = 
locale = 'zh_Hans'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hans', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[th_TH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[th_TH]

self = 
locale = 'th_TH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'th_TH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fil]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fil]

self = 
locale = 'fil'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fil', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sdh_IQ]

self = 
locale = 'sdh_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sdh_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kln]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kln]

self = 
locale = 'kln'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kln', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Deva_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Deva_IN]

self = 
locale = 'sat_Deva_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sat_Deva_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hans]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hans]

self = 
locale = 'yue_Hans'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yue_Hans', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr_TR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr_TR]

self = 
locale = 'tr_TR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tr_TR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ve]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ve]

self = , locale = 've'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 've', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IE]

self = 
locale = 'en_IE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_IE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[my]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[my]

self = , locale = 'my'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'my', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GW]

self = 
locale = 'ff_Latn_GW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_GW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lb]

self = , locale = 'lb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gd]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gd]

self = , locale = 'gd'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gd', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe_LR]

self = 
locale = 'kpe_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kpe_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ml]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ml]

self = , locale = 'ml'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ml', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Cyrl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Cyrl]

self = 
locale = 'bs_Cyrl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bs_Cyrl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro_RO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro_RO]

self = 
locale = 'ro_RO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ro_RO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PH]

self = 
locale = 'es_PH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_PH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_DZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_DZ]

self = 
locale = 'fr_DZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_DZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[haw_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[haw_US]

self = 
locale = 'haw_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'haw_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ka]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ka]

self = , locale = 'ka'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ka', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vai]

self = 
locale = 'vai'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vai', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mt]

self = , locale = 'mt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nn]

self = , locale = 'nn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lb_LU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lb_LU]

self = 
locale = 'lb_LU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lb_LU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ceb]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ceb]

self = 
locale = 'ceb'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ceb', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgo_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgo_CM]

self = 
locale = 'mgo_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mgo_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bem]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bem]

self = 
locale = 'bem'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bem', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_Arab_NG]

self = 
locale = 'ha_Arab_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_Arab_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_NC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_NC]

self = 
locale = 'fr_NC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_NC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss]

self = , locale = 'ss'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ss', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MO]

self = 
locale = 'en_MO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rof]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rof]

self = 
locale = 'rof'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rof', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap_AW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap_AW]

self = 
locale = 'pap_AW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pap_AW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MR]

self = 
locale = 'fr_MR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_UG]

self = 
locale = 'sw_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sw_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be_TARASK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be_TARASK]

self = 
locale = 'be_TARASK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'be_TARASK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mzn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mzn]

self = 
locale = 'mzn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mzn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ebu_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ebu_KE]

self = 
locale = 'ebu_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ebu_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_BN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_BN]

self = 
locale = 'ms_BN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_BN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_IT]

self = 
locale = 'it_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'it_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nyn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nyn]

self = 
locale = 'nyn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nyn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_CD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_CD]

self = 
locale = 'sw_CD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sw_CD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trv]

self = 
locale = 'trv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'trv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lg]

self = , locale = 'lg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[myv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[myv]

self = 
locale = 'myv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'myv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MP]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MP]

self = 
locale = 'en_MP'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MP', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_SE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_SE]

self = 
locale = 'sv_SE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sv_SE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[moh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[moh]

self = 
locale = 'moh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'moh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[uz_Latn]

self = 
locale = 'uz_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'uz_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgh_MZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgh_MZ]

self = 
locale = 'mgh_MZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mgh_MZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_TN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_TN]

self = 
locale = 'ar_TN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_TN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BB]

self = 
locale = 'en_BB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MF]

self = 
locale = 'fr_MF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IM]

self = 
locale = 'en_IM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_IM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PE]

self = 
locale = 'es_PE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_PE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MU]

self = 
locale = 'en_MU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_LR]

self = 
locale = 'en_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_IC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_IC]

self = 
locale = 'es_IC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_IC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kw_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kw_GB]

self = 
locale = 'kw_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kw_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_BF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_BF]

self = 
locale = 'ff_Latn_BF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_BF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha]

self = , locale = 'ha'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cad]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cad]

self = 
locale = 'cad'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cad', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr_CY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tr_CY]

self = 
locale = 'tr_CY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tr_CY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kl]

self = , locale = 'kl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nn_NO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nn_NO]

self = 
locale = 'nn_NO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nn_NO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TD]

self = 
locale = 'fr_TD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_TD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VC]

self = 
locale = 'en_VC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_VC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FI]

self = 
locale = 'en_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ceb_PH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ceb_PH]

self = 
locale = 'ceb_PH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ceb_PH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mgo]

self = 
locale = 'mgo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mgo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lt]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lt]

self = , locale = 'lt'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lt', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_KM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_KM]

self = 
locale = 'fr_KM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_KM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kn_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kn_IN]

self = 
locale = 'kn_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kn_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nr_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nr_ZA]

self = 
locale = 'nr_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nr_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[khq_ML]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[khq_ML]

self = 
locale = 'khq_ML'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'khq_ML', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_PK]

self = 
locale = 'bgn_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kcg_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kcg_NG]

self = 
locale = 'kcg_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kcg_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_MX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_MX]

self = 
locale = 'es_MX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_MX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fa]

self = , locale = 'fa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TC]

self = 
locale = 'en_TC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SS]

self = 
locale = 'en_SS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_CR]

self = 
locale = 'es_CR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_CR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_IR]

self = 
locale = 'az_Arab_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Arab_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kok]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kok]

self = 
locale = 'kok'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kok', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lij]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lij]

self = 
locale = 'lij'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lij', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksb_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksb_TZ]

self = 
locale = 'ksb_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksb_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IN]

self = 
locale = 'en_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl]

self = 
locale = 'yrl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yrl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ja]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ja]

self = , locale = 'ja'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ja', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa]

self = , locale = 'pa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mi]

self = , locale = 'mi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[saq_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[saq_KE]

self = 
locale = 'saq_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'saq_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_IR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_IR]

self = 
locale = 'bgn_IR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn_IR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wa_BE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wa_BE]

self = 
locale = 'wa_BE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wa_BE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni]

self = 
locale = 'mni'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mni', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_DJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_DJ]

self = 
locale = 'ar_DJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_DJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_TD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_TD]

self = 
locale = 'ar_TD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_TD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[si]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[si]

self = , locale = 'si'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'si', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_PM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_PM]

self = 
locale = 'fr_PM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_PM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_CH]

self = 
locale = 'de_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cho]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cho]

self = 
locale = 'cho'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cho', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cy]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cy]

self = , locale = 'cy'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cy', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da]

self = , locale = 'da'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'da', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_BA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn_BA]

self = 
locale = 'sr_Latn_BA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Latn_BA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_CN]

self = 
locale = 'zh_Hans_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hans_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shn]

self = 
locale = 'shn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sg]

self = , locale = 'sg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cv_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cv_RU]

self = 
locale = 'cv_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cv_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[osa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[osa]

self = 
locale = 'osa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'osa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kln_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kln_KE]

self = 
locale = 'kln_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kln_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_UG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_UG]

self = 
locale = 'en_UG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_UG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_CV]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_CV]

self = 
locale = 'pt_CV'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_CV', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SG]

self = 
locale = 'en_SG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong_MN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong_MN]

self = 
locale = 'mn_Mong_MN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mn_Mong_MN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CD]

self = 
locale = 'fr_CD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[aa_ER]

self = 
locale = 'aa_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'aa_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur]

self = , locale = 'ur'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ur', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_MZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_MZ]

self = 
locale = 'pt_MZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_MZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mk]

self = , locale = 'mk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ug_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ug_CN]

self = 
locale = 'ug_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ug_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti_ET]

self = 
locale = 'ti_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ti_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko]

self = , locale = 'ko'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ko', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fy]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fy]

self = , locale = 'fy'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fy', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Deva]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sat_Deva]

self = 
locale = 'sat_Deva'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sat_Deva', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ur_PK]

self = 
locale = 'ur_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ur_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[id_ID]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[id_ID]

self = 
locale = 'id_ID'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'id_ID', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lo_LA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lo_LA]

self = 
locale = 'lo_LA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lo_LA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kaj_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kaj_NG]

self = 
locale = 'kaj_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kaj_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[naq_NA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[naq_NA]

self = 
locale = 'naq_NA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'naq_NA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lij_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lij_IT]

self = 
locale = 'lij_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lij_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_TK]

self = 
locale = 'en_TK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_TK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_LU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_LU]

self = 
locale = 'pt_LU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_LU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Arab]

self = 
locale = 'bal_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bal_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_SG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hans_SG]

self = 
locale = 'zh_Hans_SG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hans_SG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn]

self = 
locale = 'bgn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SZ]

self = 
locale = 'en_SZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_PS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_PS]

self = 
locale = 'ar_PS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_PS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta]

self = , locale = 'ta'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ta', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eo_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eo_001]

self = 
locale = 'eo_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'eo_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_SM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_SM]

self = 
locale = 'it_SM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'it_SM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CY]

self = 
locale = 'en_CY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ses]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ses]

self = 
locale = 'ses'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ses', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[oc]

self = , locale = 'oc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'oc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo_FO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo_FO]

self = 
locale = 'fo_FO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fo_FO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi]

self = , locale = 'hi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal]

self = 
locale = 'bal'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bal', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tzm]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tzm]

self = 
locale = 'tzm'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tzm', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_NG]

self = 
locale = 'ff_Latn_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_BY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_BY]

self = 
locale = 'ru_BY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_BY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne_NP]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne_NP]

self = 
locale = 'ne_NP'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ne_NP', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_ET]

self = 
locale = 'so_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'so_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[twq_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[twq_NE]

self = 
locale = 'twq_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'twq_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds_NL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds_NL]

self = 
locale = 'nds_NL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nds_NL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_MK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sq_MK]

self = 
locale = 'sq_MK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sq_MK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hy_AM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hy_AM]

self = 
locale = 'hy_AM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hy_AM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_BE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_BE]

self = 
locale = 'de_BE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_BE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rwk]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rwk]

self = 
locale = 'rwk'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rwk', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln]

self = , locale = 'ln'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ln', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Deva_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Deva_IN]

self = 
locale = 'ks_Deva_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ks_Deva_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Mtei_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mni_Mtei_IN]

self = 
locale = 'mni_Mtei_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mni_Mtei_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[si_LK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[si_LK]

self = 
locale = 'si_LK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'si_LK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NR]

self = 
locale = 'en_NR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe]

self = 
locale = 'kpe'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kpe', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn]

self = , locale = 'bn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[scn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[scn]

self = 
locale = 'scn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'scn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BR]

self = 
locale = 'es_BR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_BR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[myv_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[myv_RU]

self = 
locale = 'myv_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'myv_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nqo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nqo]

self = 
locale = 'nqo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nqo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[chr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[chr]

self = 
locale = 'chr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'chr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_EA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_EA]

self = 
locale = 'es_EA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_EA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps_PK]

self = 
locale = 'ps_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ps_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_PF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_PF]

self = 
locale = 'fr_PF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_PF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so]

self = , locale = 'so'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'so', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GI]

self = 
locale = 'en_GI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yav]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yav]

self = 
locale = 'yav'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yav', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ia]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ia]

self = , locale = 'ia'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ia', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_SG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_SG]

self = 
locale = 'ms_SG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_SG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[syr_IQ]

self = 
locale = 'syr_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'syr_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgc]

self = 
locale = 'bgc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Arab_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Arab_PK]

self = 
locale = 'sd_Arab_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sd_Arab_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_VA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_VA]

self = 
locale = 'it_VA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'it_VA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vo_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vo_001]

self = 
locale = 'vo_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vo_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_001]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_001]

self = 
locale = 'ar_001'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_001', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ann]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ann]

self = 
locale = 'ann'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ann', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ab_GE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ab_GE]

self = 
locale = 'ab_GE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ab_GE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_ES]

self = 
locale = 'ca_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[an]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[an]

self = , locale = 'an'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'an', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yo]

self = , locale = 'yo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_SY]

self = 
locale = 'ar_SY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_SY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mer_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mer_KE]

self = 
locale = 'mer_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mer_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wal_ET]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wal_ET]

self = 
locale = 'wal_ET'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wal_ET', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb_SJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb_SJ]

self = 
locale = 'nb_SJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nb_SJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SX]

self = 
locale = 'en_SX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luo_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luo_KE]

self = 
locale = 'luo_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'luo_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MU]

self = 
locale = 'fr_MU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_KY]

self = 
locale = 'en_KY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_KY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[quc_GT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[quc_GT]

self = 
locale = 'quc_GT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'quc_GT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_LR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_LR]

self = 
locale = 'ff_Latn_LR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_LR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_OM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_OM]

self = 
locale = 'ar_OM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_OM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_IT]

self = 
locale = 'ca_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trv_TW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[trv_TW]

self = 
locale = 'trv_TW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'trv_TW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lu]

self = , locale = 'lu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_SX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_SX]

self = 
locale = 'nl_SX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_SX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_PE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[qu_PE]

self = 
locale = 'qu_PE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'qu_PE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ro]

self = , locale = 'ro'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ro', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sbp_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sbp_TZ]

self = 
locale = 'sbp_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sbp_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[is_IS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[is_IS]

self = 
locale = 'is_IS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'is_IS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko_KR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ko_KR]

self = 
locale = 'ko_KR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ko_KR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FK]

self = 
locale = 'en_FK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_FK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af]

self = , locale = 'af'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'af', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_MQ]

self = 
locale = 'fr_MQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_MQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[or_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[or_IN]

self = 
locale = 'or_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'or_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kam]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kam]

self = 
locale = 'kam'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kam', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw]

self = , locale = 'sw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_GR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[el_GR]

self = 
locale = 'el_GR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'el_GR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_Nkoo_ML]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bm_Nkoo_ML]

self = 
locale = 'bm_Nkoo_ML'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bm_Nkoo_ML', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cho_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cho_US]

self = 
locale = 'cho_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cho_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mer]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mer]

self = 
locale = 'mer'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mer', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vi]

self = , locale = 'vi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vun]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vun]

self = 
locale = 'vun'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vun', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mfe_MU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mfe_MU]

self = 
locale = 'mfe_MU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mfe_MU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[st_ZA]

self = 
locale = 'st_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'st_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[te_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[te_IN]

self = 
locale = 'te_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'te_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VG]

self = 
locale = 'en_VG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_VG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab]

self = 
locale = 'az_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es]

self = , locale = 'es'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksh]

self = 
locale = 'ksh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gez]

self = 
locale = 'gez'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gez', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bn_IN]

self = 
locale = 'bn_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bn_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nd]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nd]

self = , locale = 'nd'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nd', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CA]

self = 
locale = 'fr_CA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg_BD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg_BD]

self = 
locale = 'rhg_Rohg_BD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rhg_Rohg_BD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ewo_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ewo_CM]

self = 
locale = 'ewo_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ewo_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Latn]

self = 
locale = 'sr_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tpi_PG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tpi_PG]

self = 
locale = 'tpi_PG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tpi_PG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NF]

self = 
locale = 'en_NF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[no]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[no]

self = , locale = 'no'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'no', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gaa]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gaa]

self = 
locale = 'gaa'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gaa', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee]

self = , locale = 'ee'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ee', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cs_CZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cs_CZ]

self = 
locale = 'cs_CZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cs_CZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Arab_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Arab_PK]

self = 
locale = 'pa_Arab_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pa_Arab_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vi_VN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vi_VN]

self = 
locale = 'vi_VN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vi_VN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_MY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ta_MY]

self = 
locale = 'ta_MY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ta_MY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_GM]

self = 
locale = 'ff_Latn_GM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_GM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bs_Latn]

self = 
locale = 'bs_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bs_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CX]

self = 
locale = 'en_CX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_NE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ha_NE]

self = 
locale = 'ha_NE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ha_NE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[moh_CA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[moh_CA]

self = 
locale = 'moh_CA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'moh_CA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CG]

self = 
locale = 'fr_CG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dz_BT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dz_BT]

self = 
locale = 'dz_BT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dz_BT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AG]

self = 
locale = 'en_AG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wae]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wae]

self = 
locale = 'wae'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wae', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj_Hmnp]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hnj_Hmnp]

self = 
locale = 'hnj_Hmnp'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hnj_Hmnp', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[be]

self = , locale = 'be'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'be', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca]

self = , locale = 'ca'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_AX]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_AX]

self = 
locale = 'sv_AX'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sv_AX', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr_HR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr_HR]

self = 
locale = 'hr_HR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hr_HR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bho_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bho_IN]

self = 
locale = 'bho_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bho_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kk_KZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kk_KZ]

self = 
locale = 'kk_KZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kk_KZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_SR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_SR]

self = 
locale = 'nl_SR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_SR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rif]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rif]

self = 
locale = 'rif'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rif', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_KE]

self = 
locale = 'sw_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sw_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PN]

self = 
locale = 'en_PN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_SL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_SL]

self = 
locale = 'ff_Latn_SL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_SL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[byn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[byn]

self = 
locale = 'byn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'byn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kn]

self = , locale = 'kn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kcg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kcg]

self = 
locale = 'kcg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kcg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sw_TZ]

self = 
locale = 'sw_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sw_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_PW]

self = 
locale = 'en_PW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_PW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_MD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_MD]

self = 
locale = 'ru_MD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_MD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[chr_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[chr_US]

self = 
locale = 'chr_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'chr_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe_GN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kpe_GN]

self = 
locale = 'kpe_GN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kpe_GN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lag_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lag_TZ]

self = 
locale = 'lag_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lag_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_LI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[de_LI]

self = 
locale = 'de_LI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'de_LI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_MG]

self = 
locale = 'en_MG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_MG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[scn_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[scn_IT]

self = 
locale = 'scn_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'scn_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nds]

self = 
locale = 'nds'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nds', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BO]

self = 
locale = 'es_BO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_BO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[jv]

self = , locale = 'jv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'jv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Tfng_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi_Tfng_MA]

self = 
locale = 'shi_Tfng_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shi_Tfng_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xh]

self = , locale = 'xh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'xh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[km_KH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[km_KH]

self = 
locale = 'km_KH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'km_KH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kkj]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kkj]

self = 
locale = 'kkj'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kkj', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pl]

self = , locale = 'pl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cic_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cic_US]

self = 
locale = 'cic_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cic_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_FI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv_FI]

self = 
locale = 'sv_FI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sv_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[om_KE]

self = 
locale = 'om_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'om_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_KZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ru_KZ]

self = 
locale = 'ru_KZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ru_KZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lo]

self = , locale = 'lo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ti_ER]

self = 
locale = 'ti_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ti_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sn_ZW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sn_ZW]

self = 
locale = 'sn_ZW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sn_ZW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gu_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gu_IN]

self = 
locale = 'gu_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gu_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_TW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_TW]

self = 
locale = 'zh_Hant_TW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hant_TW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mus_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mus_US]

self = 
locale = 'mus_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mus_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_UY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_UY]

self = 
locale = 'es_UY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_UY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[et]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[et]

self = , locale = 'et'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'et', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wo_SN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[wo_SN]

self = 
locale = 'wo_SN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'wo_SN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_NG]

self = 
locale = 'en_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_MN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_MN]

self = 
locale = 'mn_MN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mn_MN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gl_ES]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gl_ES]

self = 
locale = 'gl_ES'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gl_ES', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gsw]

self = 
locale = 'gsw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gsw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BI]

self = 
locale = 'fr_BI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_BI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FM]

self = 
locale = 'en_FM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_FM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bss]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bss]

self = 
locale = 'bss'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bss', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sl_SI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sl_SI]

self = 
locale = 'sl_SI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sl_SI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GY]

self = 
locale = 'en_GY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[agq_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[agq_CM]

self = 
locale = 'agq_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'agq_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[my_MM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[my_MM]

self = 
locale = 'my_MM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'my_MM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[br_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[br_FR]

self = 
locale = 'br_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'br_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ig]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ig]

self = , locale = 'ig'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ig', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Arab]

self = 
locale = 'ks_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ks_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lmo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lmo]

self = 
locale = 'lmo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lmo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_CO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yrl_CO]

self = 
locale = 'yrl_CO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yrl_CO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BE]

self = 
locale = 'en_BE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_ER]

self = 
locale = 'en_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Deva_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sd_Deva_IN]

self = 
locale = 'sd_Deva_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sd_Deva_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eu]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[eu]

self = , locale = 'eu'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'eu', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ak_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ak_GH]

self = 
locale = 'ak_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ak_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_CI]

self = 
locale = 'fr_CI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_CI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dav_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dav_KE]

self = 
locale = 'dav_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dav_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks]

self = , locale = 'ks'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ks', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sv]

self = , locale = 'sv'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sv', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da_GL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da_GL]

self = 
locale = 'da_GL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'da_GL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ja_JP]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ja_JP]

self = 
locale = 'ja_JP'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ja_JP', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgc_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgc_IN]

self = 
locale = 'bgc_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgc_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ig_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ig_NG]

self = 
locale = 'ig_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ig_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mn_Mong]

self = 
locale = 'mn_Mong'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mn_Mong', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nus_SS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nus_SS]

self = 
locale = 'nus_SS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nus_SS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zgh_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zgh_MA]

self = 
locale = 'zgh_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zgh_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_DZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_DZ]

self = 
locale = 'ar_DZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_DZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mr]

self = , locale = 'mr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[as]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[as]

self = , locale = 'as'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'as', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da_DK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[da_DK]

self = 
locale = 'da_DK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'da_DK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gn_PY]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[gn_PY]

self = 
locale = 'gn_PY'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'gn_PY', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xog]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xog]

self = 
locale = 'xog'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'xog', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_WS]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_WS]

self = 
locale = 'en_WS'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_WS', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rhg_Rohg]

self = 
locale = 'rhg_Rohg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rhg_Rohg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vec]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vec]

self = 
locale = 'vec'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vec', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vec_IT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[vec_IT]

self = 
locale = 'vec_IT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'vec_IT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_CM]

self = 
locale = 'ff_Latn_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_DO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_DO]

self = 
locale = 'es_DO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_DO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BL]

self = 
locale = 'fr_BL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_BL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss_SZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ss_SZ]

self = 
locale = 'ss_SZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ss_SZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga_GB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ga_GB]

self = 
locale = 'ga_GB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ga_GB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tn_ZA]

self = 
locale = 'tn_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tn_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_IQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_IQ]

self = 
locale = 'ar_IQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_IQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GG]

self = 
locale = 'en_GG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_AT]

self = 
locale = 'en_AT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_AT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GH]

self = 
locale = 'en_GH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mdf_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mdf_RU]

self = 
locale = 'mdf_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mdf_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_ER]

self = 
locale = 'ar_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_BJ]

self = 
locale = 'fr_BJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_BJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rn_BI]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rn_BI]

self = 
locale = 'rn_BI'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rn_BI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_ST]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_ST]

self = 
locale = 'pt_ST'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_ST', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Guru_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pa_Guru_IN]

self = 
locale = 'pa_Guru_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pa_Guru_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ann_NG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ann_NG]

self = 
locale = 'ann_NG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ann_NG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_QA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_QA]

self = 
locale = 'ar_QA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_QA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas_KE]

self = 
locale = 'mas_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mas_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kgp_BR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kgp_BR]

self = 
locale = 'kgp_BR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kgp_BR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fo]

self = , locale = 'fo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_XK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr_Cyrl_XK]

self = 
locale = 'sr_Cyrl_XK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr_Cyrl_XK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_BM]

self = 
locale = 'en_BM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_BM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GD]

self = 
locale = 'en_GD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Cyrl_AZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Cyrl_AZ]

self = 
locale = 'az_Cyrl_AZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Cyrl_AZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_GU]

self = 
locale = 'en_GU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_GU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[or]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[or]

self = , locale = 'or'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'or', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ln_CF]

self = 
locale = 'ln_CF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ln_CF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ne_IN]

self = 
locale = 'ne_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ne_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_HK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_HK]

self = 
locale = 'zh_Hant_HK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hant_HK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mas_TZ]

self = 
locale = 'mas_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mas_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tig_ER]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tig_ER]

self = 
locale = 'tig_ER'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tig_ER', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xh_ZA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[xh_ZA]

self = 
locale = 'xh_ZA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'xh_ZA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yav_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yav_CM]

self = 
locale = 'yav_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yav_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sg_CF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sg_CF]

self = 
locale = 'sg_CF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sg_CF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[szl]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[szl]

self = 
locale = 'szl'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'szl', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ku_TR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ku_TR]

self = 
locale = 'ku_TR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ku_TR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kl_GL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kl_GL]

self = 
locale = 'kl_GL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kl_GL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GQ]

self = 
locale = 'fr_GQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_GQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps_AF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ps_AF]

self = 
locale = 'ps_AF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ps_AF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[kab]

self = 
locale = 'kab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'kab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[saq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[saq]

self = 
locale = 'saq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'saq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ny_MW]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ny_MW]

self = 
locale = 'ny_MW'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ny_MW', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sah_RU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sah_RU]

self = 
locale = 'sah_RU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sah_RU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_TN]

self = 
locale = 'fr_TN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_TN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_AF]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bgn_AF]

self = 
locale = 'bgn_AF'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bgn_AF', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pis_SB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pis_SB]

self = 
locale = 'pis_SB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pis_SB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[twq]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[twq]

self = 
locale = 'twq'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'twq', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_PA]

self = 
locale = 'es_PA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_PA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[sr]

self = , locale = 'sr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'sr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SB]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SB]

self = 
locale = 'en_SB'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SB', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af_NA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[af_NA]

self = 
locale = 'af_NA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'af_NA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dje]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[dje]

self = 
locale = 'dje'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'dje', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lt_LT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lt_LT]

self = 
locale = 'lt_LT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lt_LT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb_NO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nb_NO]

self = 
locale = 'nb_NO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nb_NO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[luo]

self = 
locale = 'luo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'luo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Latn]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Latn]

self = 
locale = 'az_Latn'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Latn', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_IL]

self = 
locale = 'en_IL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_IL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_BE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nl_BE]

self = 
locale = 'nl_BE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nl_BE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nnh]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[nnh]

self = 
locale = 'nnh'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'nnh', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_BZ]

self = 
locale = 'es_BZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_BZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_GQ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_GQ]

self = 
locale = 'pt_GQ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_GQ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_IL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ar_IL]

self = 
locale = 'ar_IL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ar_IL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mua_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[mua_CM]

self = 
locale = 'mua_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'mua_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_MO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pt_MO]

self = 
locale = 'pt_MO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pt_MO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Arab_PK]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[bal_Arab_PK]

self = 
locale = 'bal_Arab_PK'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'bal_Arab_PK', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rof_TZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rof_TZ]

self = 
locale = 'rof_TZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rof_TZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[pap]

self = 
locale = 'pap'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'pap', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hans_CN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[yue_Hans_CN]

self = 
locale = 'yue_Hans_CN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'yue_Hans_CN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[haw]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[haw]

self = 
locale = 'haw'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'haw', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SL]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SL]

self = 
locale = 'en_SL'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SL', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_Latn_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_Latn_IN]

self = 
locale = 'hi_Latn_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hi_Latn_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[blt_VN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[blt_VN]

self = 
locale = 'blt_VN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'blt_VN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_HN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_HN]

self = 
locale = 'es_HN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_HN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[seh_MZ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[seh_MZ]

self = 
locale = 'seh_MZ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'seh_MZ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee_TG]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ee_TG]

self = 
locale = 'ee_TG'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ee_TG', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ewo]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ewo]

self = 
locale = 'ewo'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ewo', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hy]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hy]

self = , locale = 'hy'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hy', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_KE]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[so_KE]

self = 
locale = 'so_KE'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'so_KE', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ts]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ts]

self = , locale = 'ts'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ts', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[th]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[th]

self = , locale = 'th'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'th', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Deva]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ks_Deva]

self = 
locale = 'ks_Deva'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ks_Deva', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_MR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ff_Latn_MR]

self = 
locale = 'ff_Latn_MR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ff_Latn_MR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[doi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[doi]

self = 
locale = 'doi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'doi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_FR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ca_FR]

self = 
locale = 'ca_FR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_FR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_CH]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[it_CH]

self = 
locale = 'it_CH'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'it_CH', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_YT]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_YT]

self = 
locale = 'fr_YT'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_YT', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VU]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_VU]

self = 
locale = 'en_VU'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_VU', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tzm_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tzm_MA]

self = 
locale = 'tzm_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tzm_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SC]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SC]

self = 
locale = 'en_SC'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SC', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tpi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tpi]

self = 
locale = 'tpi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tpi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GP]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fr_GP]

self = 
locale = 'fr_GP'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fr_GP', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_CA]

self = 
locale = 'en_CA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_CA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_MO]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[zh_Hant_MO]

self = 
locale = 'zh_Hant_MO'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'zh_Hant_MO', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[raj_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[raj_IN]

self = 
locale = 'raj_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'raj_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_US]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[es_US]

self = 
locale = 'es_US'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'es_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksf_CM]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ksf_CM]

self = 
locale = 'ksf_CM'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ksf_CM', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FJ]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_FJ]

self = 
locale = 'en_FJ'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_FJ', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cic]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[cic]

self = 
locale = 'cic'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'cic', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tg]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[tg]

self = , locale = 'tg'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'tg', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[smj]

self = 
locale = 'smj'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'smj', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ses_ML]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ses_ML]

self = 
locale = 'ses_ML'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ses_ML', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[ms_Arab]

self = 
locale = 'ms_Arab'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ms_Arab', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fur]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[fur]

self = 
locale = 'fur'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fur', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hr]

self = , locale = 'hr'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hr', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rif_MA]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[rif_MA]

self = 
locale = 'rif_MA'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'rif_MA', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[shi]

self = 
locale = 'shi'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'shi', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SD]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_SD]

self = 
locale = 'en_SD'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_SD', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_150]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[en_150]

self = 
locale = 'en_150'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_150', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_TR]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[az_Arab_TR]

self = 
locale = 'az_Arab_TR'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'az_Arab_TR', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[lrc]

self = 
locale = 'lrc'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'lrc', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_IN]

test_core.py::TestLocaleClass::test_all_locales_have_default_numbering_system[hi_IN]

self = 
locale = 'hi_IN'

    @pytest.mark.all_locales
    def test_all_locales_have_default_numbering_system(self, locale):
>       locale = Locale.parse(locale)

tests/test_core.py:182: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'hi_IN', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::TestLocaleClass::test_decimal_formats

test_core.py::TestLocaleClass::test_decimal_formats

self = 

    def test_decimal_formats(self):
>       assert Locale('en', 'US').decimal_formats[None].pattern == '#,##0.###'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:186: TypeError

test_core.py::TestLocaleClass::test_currency_formats_property

test_core.py::TestLocaleClass::test_currency_formats_property

self = 

    def test_currency_formats_property(self):
>       assert (Locale('en', 'US').currency_formats['standard'].pattern ==
                '\xa4#,##0.00')
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:189: TypeError

test_core.py::TestLocaleClass::test_percent_formats_property

test_core.py::TestLocaleClass::test_percent_formats_property

self = 

    def test_percent_formats_property(self):
>       assert Locale('en', 'US').percent_formats[None].pattern == '#,##0%'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:195: TypeError

test_core.py::TestLocaleClass::test_scientific_formats_property

test_core.py::TestLocaleClass::test_scientific_formats_property

self = 

    def test_scientific_formats_property(self):
>       assert Locale('en', 'US').scientific_formats[None].pattern == '#E0'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:198: TypeError

test_core.py::TestLocaleClass::test_periods_property

test_core.py::TestLocaleClass::test_periods_property

self = 

    def test_periods_property(self):
>       assert Locale('en', 'US').periods['am'] == 'AM'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:201: TypeError

test_core.py::TestLocaleClass::test_days_property

test_core.py::TestLocaleClass::test_days_property

self = 

    def test_days_property(self):
>       assert Locale('de', 'DE').days['format']['wide'][3] == 'Donnerstag'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:204: TypeError

test_core.py::TestLocaleClass::test_months_property

test_core.py::TestLocaleClass::test_months_property

self = 

    def test_months_property(self):
>       assert Locale('de', 'DE').months['format']['wide'][10] == 'Oktober'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:207: TypeError

test_core.py::TestLocaleClass::test_quarters_property

test_core.py::TestLocaleClass::test_quarters_property

self = 

    def test_quarters_property(self):
>       assert Locale('de', 'DE').quarters['format']['wide'][1] == '1. Quartal'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:210: TypeError

test_core.py::TestLocaleClass::test_eras_property

test_core.py::TestLocaleClass::test_eras_property

self = 

    def test_eras_property(self):
>       assert Locale('en', 'US').eras['wide'][1] == 'Anno Domini'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:213: TypeError

test_core.py::TestLocaleClass::test_time_zones_property

test_core.py::TestLocaleClass::test_time_zones_property

self = 

    def test_time_zones_property(self):
        time_zones = Locale('en', 'US').time_zones
>       assert (time_zones['Europe/London']['long']['daylight'] ==
                'British Summer Time')
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:218: TypeError

test_core.py::TestLocaleClass::test_meta_zones_property

test_core.py::TestLocaleClass::test_meta_zones_property

self = 

    def test_meta_zones_property(self):
        meta_zones = Locale('en', 'US').meta_zones
>       assert (meta_zones['Europe_Central']['long']['daylight'] ==
                'Central European Summer Time')
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:224: TypeError

test_core.py::TestLocaleClass::test_zone_formats_property

test_core.py::TestLocaleClass::test_zone_formats_property

self = 

    def test_zone_formats_property(self):
>       assert Locale('en', 'US').zone_formats['fallback'] == '%(1)s (%(0)s)'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:228: TypeError

test_core.py::TestLocaleClass::test_first_week_day_property

test_core.py::TestLocaleClass::test_first_week_day_property

self = 

    def test_first_week_day_property(self):
>       assert Locale('de', 'DE').first_week_day == 0
E       AssertionError: assert None == 0
E        +  where None = Locale('de', territory='DE').first_week_day
E        +    where Locale('de', territory='DE') = Locale('de', 'DE')

tests/test_core.py:232: AssertionError

test_core.py::TestLocaleClass::test_weekend_start_property

test_core.py::TestLocaleClass::test_weekend_start_property

self = 

    def test_weekend_start_property(self):
>       assert Locale('de', 'DE').weekend_start == 5
E       AssertionError: assert None == 5
E        +  where None = Locale('de', territory='DE').weekend_start
E        +    where Locale('de', territory='DE') = Locale('de', 'DE')

tests/test_core.py:236: AssertionError

test_core.py::TestLocaleClass::test_weekend_end_property

test_core.py::TestLocaleClass::test_weekend_end_property

self = 

    def test_weekend_end_property(self):
>       assert Locale('de', 'DE').weekend_end == 6
E       AssertionError: assert None == 6
E        +  where None = Locale('de', territory='DE').weekend_end
E        +    where Locale('de', territory='DE') = Locale('de', 'DE')

tests/test_core.py:239: AssertionError

test_core.py::TestLocaleClass::test_min_week_days_property

test_core.py::TestLocaleClass::test_min_week_days_property

self = 

    def test_min_week_days_property(self):
>       assert Locale('de', 'DE').min_week_days == 4
E       AssertionError: assert None == 4
E        +  where None = Locale('de', territory='DE').min_week_days
E        +    where Locale('de', territory='DE') = Locale('de', 'DE')

tests/test_core.py:242: AssertionError

test_core.py::TestLocaleClass::test_date_formats_property

test_core.py::TestLocaleClass::test_date_formats_property

self = 

    def test_date_formats_property(self):
>       assert Locale('en', 'US').date_formats['short'].pattern == 'M/d/yy'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:245: TypeError

test_core.py::TestLocaleClass::test_time_formats_property

test_core.py::TestLocaleClass::test_time_formats_property

self = 

    def test_time_formats_property(self):
>       assert Locale('en', 'US').time_formats['short'].pattern == 'h:mm\u202fa'
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:249: TypeError

test_core.py::TestLocaleClass::test_datetime_formats_property

test_core.py::TestLocaleClass::test_datetime_formats_property

self = 

    def test_datetime_formats_property(self):
>       assert Locale('en').datetime_formats['full'] == "{1}, {0}"
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:253: TypeError

test_core.py::TestLocaleClass::test_datetime_skeleton_property

test_core.py::TestLocaleClass::test_datetime_skeleton_property

self = 

    def test_datetime_skeleton_property(self):
>       assert Locale('en').datetime_skeletons['Md'].pattern == "M/d"
E       TypeError: 'NoneType' object is not subscriptable

tests/test_core.py:257: TypeError

test_core.py::TestLocaleClass::test_plural_form_property

test_core.py::TestLocaleClass::test_plural_form_property

self = 

    def test_plural_form_property(self):
>       assert Locale('en').plural_form(1) == 'one'
E       TypeError: 'NoneType' object is not callable

tests/test_core.py:261: TypeError

test_core.py::test_default_locale

test_core.py::test_default_locale

os_environ = {'BLIS_NUM_THREADS': '1', 'CFLAGS': '-g0', 'HOME': '/root', 'LANG': 'fr_FR.UTF-8', ...}

    def test_default_locale(os_environ):
        for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
            os_environ[name] = ''
        os_environ['LANG'] = 'fr_FR.UTF-8'
        assert default_locale('LC_MESSAGES') == 'fr_FR'

        os_environ['LC_MESSAGES'] = 'POSIX'
        assert default_locale('LC_MESSAGES') == 'en_US_POSIX'

        for value in ['C', 'C.UTF-8', 'POSIX']:
            os_environ['LANGUAGE'] = value
>           assert default_locale() == 'en_US_POSIX'
E           AssertionError: assert 'C' == 'en_US_POSIX'
E             
E             - en_US_POSIX
E             + C

tests/test_core.py:278: AssertionError

test_core.py::test_negotiate_locale

test_core.py::test_negotiate_locale

def test_negotiate_locale():
>       assert (core.negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT']) ==
                'de_DE')
E       AssertionError: assert 'de_de' == 'de_DE'
E         
E         - de_DE
E         + de_de

tests/test_core.py:282: AssertionError

test_core.py::test_parse_locale

test_core.py::test_parse_locale

def test_parse_locale():
        assert core.parse_locale('zh_CN') == ('zh', 'CN', None, None)
        assert core.parse_locale('zh_Hans_CN') == ('zh', 'CN', 'Hans', None)
        assert core.parse_locale('zh-CN', sep='-') == ('zh', 'CN', None, None)

        with pytest.raises(ValueError) as excinfo:
            core.parse_locale('not_a_LOCALE_String')
        assert (excinfo.value.args[0] ==
                "'not_a_LOCALE_String' is not a valid locale identifier")

        assert core.parse_locale('it_IT@euro') == ('it', 'IT', None, None, 'euro')
        assert core.parse_locale('it_IT@something') == ('it', 'IT', None, None, 'something')

>       assert core.parse_locale('en_US.UTF-8') == ('en', 'US', None, None)
E       AssertionError: assert ('en', None, None, 'US.UTF-8') == ('en', 'US', None, None)
E         
E         At index 1 diff: None != 'US'
E         Use -v to get more diff

tests/test_core.py:307: AssertionError

root.dat]

root.dat]

filename = 'babel/locale-data/root.dat'

    @pytest.mark.parametrize('filename', [
        'babel/global.dat',
        'babel/locale-data/root.dat',
        'babel/locale-data/en.dat',
        'babel/locale-data/en_US.dat',
        'babel/locale-data/en_US_POSIX.dat',
        'babel/locale-data/zh_Hans_CN.dat',
        'babel/locale-data/zh_Hant_TW.dat',
        'babel/locale-data/es_419.dat',
    ])
    def test_compatible_classes_in_global_and_localedata(filename):
        import pickle

        class Unpickler(pickle.Unpickler):

            def find_class(self, module, name):
                # *.dat files must have compatible classes between Python 2 and 3
                if module.split('.')[0] == 'babel':
                    return pickle.Unpickler.find_class(self, module, name)
                raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")

        with open(filename, 'rb') as f:
>           assert Unpickler(f).load()

tests/test_core.py:334: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_core.py:330: in find_class
    return pickle.Unpickler.find_class(self, module, name)
babel/dates.py:29: in 
    from babel import localtime
babel/localtime/__init__.py:18: in 
    from babel.localtime._unix import _get_localzone
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    import datetime
    import os
    import re
>   from babel.localtime._helpers import _get_tzinfo, _get_tzinfo_from_file, _get_tzinfo_or_raise
E   ImportError: cannot import name '_get_tzinfo_from_file' from 'babel.localtime._helpers' (/testbed/babel/localtime/_helpers.py)

babel/localtime/_unix.py:4: ImportError

en.dat]

en.dat]

filename = 'babel/locale-data/en.dat'

    @pytest.mark.parametrize('filename', [
        'babel/global.dat',
        'babel/locale-data/root.dat',
        'babel/locale-data/en.dat',
        'babel/locale-data/en_US.dat',
        'babel/locale-data/en_US_POSIX.dat',
        'babel/locale-data/zh_Hans_CN.dat',
        'babel/locale-data/zh_Hant_TW.dat',
        'babel/locale-data/es_419.dat',
    ])
    def test_compatible_classes_in_global_and_localedata(filename):
        import pickle

        class Unpickler(pickle.Unpickler):

            def find_class(self, module, name):
                # *.dat files must have compatible classes between Python 2 and 3
                if module.split('.')[0] == 'babel':
                    return pickle.Unpickler.find_class(self, module, name)
                raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")

        with open(filename, 'rb') as f:
>           assert Unpickler(f).load()

tests/test_core.py:334: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_core.py:330: in find_class
    return pickle.Unpickler.find_class(self, module, name)
babel/dates.py:29: in 
    from babel import localtime
babel/localtime/__init__.py:18: in 
    from babel.localtime._unix import _get_localzone
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    import datetime
    import os
    import re
>   from babel.localtime._helpers import _get_tzinfo, _get_tzinfo_from_file, _get_tzinfo_or_raise
E   ImportError: cannot import name '_get_tzinfo_from_file' from 'babel.localtime._helpers' (/testbed/babel/localtime/_helpers.py)

babel/localtime/_unix.py:4: ImportError

es_419.dat]

es_419.dat]

filename = 'babel/locale-data/es_419.dat'

    @pytest.mark.parametrize('filename', [
        'babel/global.dat',
        'babel/locale-data/root.dat',
        'babel/locale-data/en.dat',
        'babel/locale-data/en_US.dat',
        'babel/locale-data/en_US_POSIX.dat',
        'babel/locale-data/zh_Hans_CN.dat',
        'babel/locale-data/zh_Hant_TW.dat',
        'babel/locale-data/es_419.dat',
    ])
    def test_compatible_classes_in_global_and_localedata(filename):
        import pickle

        class Unpickler(pickle.Unpickler):

            def find_class(self, module, name):
                # *.dat files must have compatible classes between Python 2 and 3
                if module.split('.')[0] == 'babel':
                    return pickle.Unpickler.find_class(self, module, name)
                raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")

        with open(filename, 'rb') as f:
>           assert Unpickler(f).load()

tests/test_core.py:334: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/test_core.py:330: in find_class
    return pickle.Unpickler.find_class(self, module, name)
babel/dates.py:29: in 
    from babel import localtime
babel/localtime/__init__.py:18: in 
    from babel.localtime._unix import _get_localzone
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    import datetime
    import os
    import re
>   from babel.localtime._helpers import _get_tzinfo, _get_tzinfo_from_file, _get_tzinfo_or_raise
E   ImportError: cannot import name '_get_tzinfo_from_file' from 'babel.localtime._helpers' (/testbed/babel/localtime/_helpers.py)

babel/localtime/_unix.py:4: ImportError

test_core.py::test_issue_601_no_language_name_but_has_variant

test_core.py::test_issue_601_no_language_name_but_has_variant

def test_issue_601_no_language_name_but_has_variant():
        # kw_GB has a variant for Finnish but no actual language name for Finnish,
        # so `get_display_name()` previously crashed with a TypeError as it attempted
        # to concatenate " (Finnish)" to None.
        # Instead, it's better to return None altogether, as we can't reliably format
        # part of a language name.

>       assert Locale.parse('fi_FI').get_display_name('kw_GB') is None

tests/test_core.py:344: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'fi_FI', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_core.py::test_issue_814

test_core.py::test_issue_814

def test_issue_814():
>       loc = Locale.parse('ca_ES_valencia')

tests/test_core.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ca_ES_valencia', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_lists.py::test_format_list

test_lists.py::test_format_list

def test_format_list():
        for list, locale, expected in [
            ([], 'en', ''),
            (['string'], 'en', 'string'),
            (['string1', 'string2'], 'en', 'string1 and string2'),
            (['string1', 'string2', 'string3'], 'en', 'string1, string2, and string3'),
            (['string1', 'string2', 'string3'], 'zh', 'string1、string2和string3'),
            (['string1', 'string2', 'string3', 'string4'], 'ne', 'string1,string2, string3 र string4'),
        ]:
>           assert lists.format_list(list, locale=locale) == expected

tests/test_lists.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/lists.py:75: in format_list
    locale_obj = Locale.parse(locale) if isinstance(locale, str) else locale or DEFAULT_LOCALE
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_localedata.py::MergeResolveTestCase::test_merge_with_alias_and_resolve

test_localedata.py::MergeResolveTestCase::test_merge_with_alias_and_resolve

self = 

    def test_merge_with_alias_and_resolve(self):
        alias = localedata.Alias('x')
        d1 = {
            'x': {'a': 1, 'b': 2, 'c': 3},
            'y': alias,
        }
        d2 = {
            'x': {'a': 1, 'b': 12, 'd': 14},
            'y': {'b': 22, 'e': 25},
        }
        localedata.merge(d1, d2)
>       assert d1 == {'x': {'a': 1, 'b': 12, 'c': 3, 'd': 14}, 'y': (alias, {'b': 22, 'e': 25})}
E       AssertionError: assert {'x': {'a': 1... 22, 'e': 25}} == {'x': {'a': 1...22, 'e': 25})}
E         
E         Omitting 1 identical items, use -vv to show
E         Differing items:
E         {'y': {'b': 22, 'e': 25}} != {'y': (, {'b': 22, 'e': 25})}
E         Use -v to get more diff

tests/test_localedata.py:56: AssertionError

test_localedata.py::test_load

test_localedata.py::test_load

def test_load():
>       assert localedata.load('en_US')['languages']['sv'] == 'Swedish'

tests/test_localedata.py:62: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , key = 'sv'

    def __getitem__(self, key: (str | int | None)) ->Any:
>       orig = val = self._data[key]
E       KeyError: 'sv'

babel/localedata.py:212: KeyError

test_localedata.py::test_mixedcased_locale

test_localedata.py::test_mixedcased_locale

def test_mixedcased_locale():
        for locale in localedata.locale_identifiers():
            locale_id = ''.join([
                methodcaller(random.choice(['lower', 'upper']))(c) for c in locale])
>           assert localedata.exists(locale_id)
E           AssertionError: assert False
E            +  where False = ('Ff_latn_GN')
E            +    where  = localedata.exists

tests/test_localedata.py:90: AssertionError

test_localedata.py::test_locale_argument_acceptance

test_localedata.py::test_locale_argument_acceptance

def test_locale_argument_acceptance():
        # Testing None input.
>       normalized_locale = localedata.normalize_locale(None)

tests/test_localedata.py:95: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

name = None

    def normalize_locale(name: str) ->(str | None):
        """Normalize a locale ID by stripping spaces and apply proper casing.

        Returns the normalized locale ID string or `None` if the ID is not
        recognized.
        """
>       name = name.strip().lower()
E       AttributeError: 'NoneType' object has no attribute 'strip'

babel/localedata.py:37: AttributeError

test_localedata.py::test_locale_name_cleanup

test_localedata.py::test_locale_name_cleanup

def test_locale_name_cleanup():
        """
        Test that locale identifiers are cleaned up to avoid directory traversal.
        """
        no_exist_name = os.path.join(tempfile.gettempdir(), "babel%d.dat" % random.randint(1, 99999))
        with open(no_exist_name, "wb") as f:
            pickle.dump({}, f)

        try:
            name = os.path.splitext(os.path.relpath(no_exist_name, localedata._dirname))[0]
        except ValueError:
            if sys.platform == "win32":
                pytest.skip("unable to form relpath")
            raise

>       assert not localedata.exists(name)
E       AssertionError: assert not True
E        +  where True = ('../../../tmp/babel12224')
E        +    where  = localedata.exists

tests/test_localedata.py:141: AssertionError

test_numbers.py::FormatDecimalTestCase::test_compact

test_numbers.py::FormatDecimalTestCase::test_compact

self = 

    def test_compact(self):
>       assert numbers.format_compact_decimal(1, locale='en_US', format_type="short") == '1'
E       AssertionError: assert None == '1'
E        +  where None = (1, locale='en_US', format_type='short')
E        +    where  = numbers.format_compact_decimal

tests/test_numbers.py:142: AssertionError

test_numbers.py::FormatDecimalTestCase::test_decimals

test_numbers.py::FormatDecimalTestCase::test_decimals

self = 

    def test_decimals(self):
        """Test significant digits patterns"""
>       assert numbers.format_decimal(decimal.Decimal('1.2345'), '#.00', locale='en_US') == '1.23'
E       AssertionError: assert None == '1.23'
E        +  where None = (Decimal('1.2345'), '#.00', locale='en_US')
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.2345') = ('1.2345')
E        +      where  = decimal.Decimal

tests/test_numbers.py:82: AssertionError

test_numbers.py::FormatDecimalTestCase::test_default_rounding

test_numbers.py::FormatDecimalTestCase::test_default_rounding

self = 

    def test_default_rounding(self):
        """
        Testing Round-Half-Even (Banker's rounding)

        A '5' is rounded to the closest 'even' number
        """
>       assert numbers.format_decimal(5.5, '0', locale='sv') == '6'
E       AssertionError: assert None == '6'
E        +  where None = (5.5, '0', locale='sv')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:53: AssertionError

test_numbers.py::FormatDecimalTestCase::test_formatting_of_very_small_decimals

test_numbers.py::FormatDecimalTestCase::test_formatting_of_very_small_decimals

self = 

    def test_formatting_of_very_small_decimals(self):
        # previously formatting very small decimals could lead to a type error
        # because the Decimal->string conversion was too simple (see #214)
        number = decimal.Decimal("7E-7")
>       assert numbers.format_decimal(number, format="@@@", locale='en_US') == '0.000000700'
E       AssertionError: assert None == '0.000000700'
E        +  where None = (Decimal('7E-7'), format='@@@', locale='en_US')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:112: AssertionError

test_numbers.py::FormatDecimalTestCase::test_group_separator

test_numbers.py::FormatDecimalTestCase::test_group_separator

self = 

    def test_group_separator(self):
>       assert numbers.format_decimal(29567.12, locale='en_US', group_separator=False) == '29567.12'
E       AssertionError: assert None == '29567.12'
E        +  where None = (29567.12, locale='en_US', group_separator=False)
E        +    where  = numbers.format_decimal

tests/test_numbers.py:125: AssertionError

test_numbers.py::FormatDecimalTestCase::test_nan_and_infinity

test_numbers.py::FormatDecimalTestCase::test_nan_and_infinity

self = 

    def test_nan_and_infinity(self):
>       assert numbers.format_decimal(decimal.Decimal('Infinity'), locale='en_US') == '∞'
E       AssertionError: assert None == '∞'
E        +  where None = (Decimal('Infinity'), locale='en_US')
E        +    where  = numbers.format_decimal
E        +    and   Decimal('Infinity') = ('Infinity')
E        +      where  = decimal.Decimal

tests/test_numbers.py:115: AssertionError

test_numbers.py::FormatDecimalTestCase::test_patterns

test_numbers.py::FormatDecimalTestCase::test_patterns

self = 

    def test_patterns(self):
>       assert numbers.format_decimal(12345, '##0', locale='en_US') == '12345'
E       AssertionError: assert None == '12345'
E        +  where None = (12345, '##0', locale='en_US')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:35: AssertionError

test_numbers.py::FormatDecimalTestCase::test_scientific_notation

test_numbers.py::FormatDecimalTestCase::test_scientific_notation

self = 

    def test_scientific_notation(self):
>       assert numbers.format_scientific(0.1, '#E0', locale='en_US') == '1E-1'
E       AssertionError: assert None == '1E-1'
E        +  where None = (0.1, '#E0', locale='en_US')
E        +    where  = numbers.format_scientific

tests/test_numbers.py:88: AssertionError

test_numbers.py::FormatDecimalTestCase::test_significant_digits

test_numbers.py::FormatDecimalTestCase::test_significant_digits

self = 

    def test_significant_digits(self):
        """Test significant digits patterns"""
>       assert numbers.format_decimal(123004, '@@', locale='en_US') == '120000'
E       AssertionError: assert None == '120000'
E        +  where None = (123004, '@@', locale='en_US')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:61: AssertionError

test_numbers.py::FormatDecimalTestCase::test_subpatterns

test_numbers.py::FormatDecimalTestCase::test_subpatterns

self = 

    def test_subpatterns(self):
>       assert numbers.format_decimal((- 12345), '#,##0.##;-#', locale='en_US') == '-12,345'
E       AssertionError: assert None == '-12,345'
E        +  where None = (-12345, '#,##0.##;-#', locale='en_US')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:44: AssertionError

test_numbers.py::NumberParsingTestCase::test_can_parse_decimals

test_numbers.py::NumberParsingTestCase::test_can_parse_decimals

self = 

    def test_can_parse_decimals(self):
>       assert decimal.Decimal('1099.98') == numbers.parse_decimal('1,099.98', locale='en_US')
E       AssertionError: assert Decimal('1099.98') == None
E        +  where Decimal('1099.98') = ('1099.98')
E        +    where  = decimal.Decimal
E        +  and   None = ('1,099.98', locale='en_US')
E        +    where  = numbers.parse_decimal

tests/test_numbers.py:190: AssertionError

test_numbers.py::NumberParsingTestCase::test_parse_decimal_strict_mode

test_numbers.py::NumberParsingTestCase::test_parse_decimal_strict_mode

self = 

    def test_parse_decimal_strict_mode(self):
        # Numbers with a misplaced grouping symbol should be rejected
>       with pytest.raises(numbers.NumberFormatError) as info:
E       Failed: DID NOT RAISE 

tests/test_numbers.py:200: Failed

test_numbers.py::test_list_currencies

test_numbers.py::test_list_currencies

def test_list_currencies():
>       assert isinstance(list_currencies(), set)

tests/test_numbers.py:241: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:53: in list_currencies
    return set(get_global('currency_names').keys())
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

key = 'currency_names'

    def get_global(key: _GLOBAL_KEY) ->Mapping[str, Any]:
        """Return the dictionary for the given key in the global data.

        The global data is stored in the ``babel/global.dat`` file and contains
        information independent of individual locales.

        >>> get_global('zone_aliases')['UTC']
        u'Etc/UTC'
        >>> get_global('zone_territories')['Europe/Berlin']
        u'DE'

        The keys available are:

        - ``all_currencies``
        - ``currency_fractions``
        - ``language_aliases``
        - ``likely_subtags``
        - ``parent_exceptions``
        - ``script_aliases``
        - ``territory_aliases``
        - ``territory_currencies``
        - ``territory_languages``
        - ``territory_zones``
        - ``variant_aliases``
        - ``windows_zone_mapping``
        - ``zone_aliases``
        - ``zone_territories``

        .. note:: The internal structure of the data may change between versions.

        .. versionadded:: 0.9

        :param key: the data key
        """
        global _global_data
        if _global_data is None:
            dirname = os.path.join(os.path.dirname(__file__), 'global.dat')
            with open(dirname, 'rb') as f:
                _global_data = pickle.load(f)
>       return _global_data[key]
E       KeyError: 'currency_names'

babel/core.py:71: KeyError

test_numbers.py::test_validate_currency

test_numbers.py::test_validate_currency

def test_validate_currency():
>       validate_currency('EUR')

tests/test_numbers.py:257: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:69: in validate_currency
    if currency not in list_currencies(locale):
babel/numbers.py:53: in list_currencies
    return set(get_global('currency_names').keys())
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

key = 'currency_names'

    def get_global(key: _GLOBAL_KEY) ->Mapping[str, Any]:
        """Return the dictionary for the given key in the global data.

        The global data is stored in the ``babel/global.dat`` file and contains
        information independent of individual locales.

        >>> get_global('zone_aliases')['UTC']
        u'Etc/UTC'
        >>> get_global('zone_territories')['Europe/Berlin']
        u'DE'

        The keys available are:

        - ``all_currencies``
        - ``currency_fractions``
        - ``language_aliases``
        - ``likely_subtags``
        - ``parent_exceptions``
        - ``script_aliases``
        - ``territory_aliases``
        - ``territory_currencies``
        - ``territory_languages``
        - ``territory_zones``
        - ``variant_aliases``
        - ``windows_zone_mapping``
        - ``zone_aliases``
        - ``zone_territories``

        .. note:: The internal structure of the data may change between versions.

        .. versionadded:: 0.9

        :param key: the data key
        """
        global _global_data
        if _global_data is None:
            dirname = os.path.join(os.path.dirname(__file__), 'global.dat')
            with open(dirname, 'rb') as f:
                _global_data = pickle.load(f)
>       return _global_data[key]
E       KeyError: 'currency_names'

babel/core.py:71: KeyError

test_numbers.py::test_is_currency

test_numbers.py::test_is_currency

def test_is_currency():
>       assert is_currency('EUR')

tests/test_numbers.py:265: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:79: in is_currency
    validate_currency(currency, locale)
babel/numbers.py:69: in validate_currency
    if currency not in list_currencies(locale):
babel/numbers.py:53: in list_currencies
    return set(get_global('currency_names').keys())
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

key = 'currency_names'

    def get_global(key: _GLOBAL_KEY) ->Mapping[str, Any]:
        """Return the dictionary for the given key in the global data.

        The global data is stored in the ``babel/global.dat`` file and contains
        information independent of individual locales.

        >>> get_global('zone_aliases')['UTC']
        u'Etc/UTC'
        >>> get_global('zone_territories')['Europe/Berlin']
        u'DE'

        The keys available are:

        - ``all_currencies``
        - ``currency_fractions``
        - ``language_aliases``
        - ``likely_subtags``
        - ``parent_exceptions``
        - ``script_aliases``
        - ``territory_aliases``
        - ``territory_currencies``
        - ``territory_languages``
        - ``territory_zones``
        - ``variant_aliases``
        - ``windows_zone_mapping``
        - ``zone_aliases``
        - ``zone_territories``

        .. note:: The internal structure of the data may change between versions.

        .. versionadded:: 0.9

        :param key: the data key
        """
        global _global_data
        if _global_data is None:
            dirname = os.path.join(os.path.dirname(__file__), 'global.dat')
            with open(dirname, 'rb') as f:
                _global_data = pickle.load(f)
>       return _global_data[key]
E       KeyError: 'currency_names'

babel/core.py:71: KeyError

test_numbers.py::test_normalize_currency

test_numbers.py::test_normalize_currency

def test_normalize_currency():
>       assert normalize_currency('EUR') == 'EUR'

tests/test_numbers.py:277: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:95: in normalize_currency
    validate_currency(currency, locale)
babel/numbers.py:69: in validate_currency
    if currency not in list_currencies(locale):
babel/numbers.py:53: in list_currencies
    return set(get_global('currency_names').keys())
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

key = 'currency_names'

    def get_global(key: _GLOBAL_KEY) ->Mapping[str, Any]:
        """Return the dictionary for the given key in the global data.

        The global data is stored in the ``babel/global.dat`` file and contains
        information independent of individual locales.

        >>> get_global('zone_aliases')['UTC']
        u'Etc/UTC'
        >>> get_global('zone_territories')['Europe/Berlin']
        u'DE'

        The keys available are:

        - ``all_currencies``
        - ``currency_fractions``
        - ``language_aliases``
        - ``likely_subtags``
        - ``parent_exceptions``
        - ``script_aliases``
        - ``territory_aliases``
        - ``territory_currencies``
        - ``territory_languages``
        - ``territory_zones``
        - ``variant_aliases``
        - ``windows_zone_mapping``
        - ``zone_aliases``
        - ``zone_territories``

        .. note:: The internal structure of the data may change between versions.

        .. versionadded:: 0.9

        :param key: the data key
        """
        global _global_data
        if _global_data is None:
            dirname = os.path.join(os.path.dirname(__file__), 'global.dat')
            with open(dirname, 'rb') as f:
                _global_data = pickle.load(f)
>       return _global_data[key]
E       KeyError: 'currency_names'

babel/core.py:71: KeyError

test_numbers.py::test_get_currency_name

test_numbers.py::test_get_currency_name

def test_get_currency_name():
>       assert numbers.get_currency_name('USD', locale='en_US') == 'US Dollar'

tests/test_numbers.py:289: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:115: in get_currency_name
    locale = Locale.parse(locale)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_numbers.py::test_get_currency_symbol

test_numbers.py::test_get_currency_symbol

def test_get_currency_symbol():
>       assert numbers.get_currency_symbol('USD', 'en_US') == '$'

tests/test_numbers.py:294: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:132: in get_currency_symbol
    locale = Locale.parse(locale)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_numbers.py::test_get_currency_precision

test_numbers.py::test_get_currency_precision

def test_get_currency_precision():
        assert get_currency_precision('EUR') == 2
>       assert get_currency_precision('JPY') == 0

tests/test_numbers.py:299: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

currency = 'JPY'

    def get_currency_precision(currency: str) ->int:
        """Return currency's precision.

        Precision is the number of decimals found after the decimal point in the
        currency's format pattern.

        .. versionadded:: 2.5.0

        :param currency: the currency code.
        """
>       return get_global('currency_fractions').get(currency, {}).get('digits', 2)
E       AttributeError: 'tuple' object has no attribute 'get'

babel/numbers.py:146: AttributeError

test_numbers.py::test_get_currency_unit_pattern

test_numbers.py::test_get_currency_unit_pattern

def test_get_currency_unit_pattern():
>       assert get_currency_unit_pattern('USD', locale='en_US') == '{0} {1}'

tests/test_numbers.py:303: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/numbers.py:168: in get_currency_unit_pattern
    locale = Locale.parse(locale)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'en_US', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_numbers.py::test_get_territory_currencies

test_numbers.py::test_get_territory_currencies

def test_get_territory_currencies():
>       assert numbers.get_territory_currencies('AT', date(1995, 1, 1)) == ['ATS']
E       AssertionError: assert None == ['ATS']
E        +  where None = ('AT', datetime.date(1995, 1, 1))
E        +    where  = numbers.get_territory_currencies
E        +    and   datetime.date(1995, 1, 1) = date(1995, 1, 1)

tests/test_numbers.py:314: AssertionError

test_numbers.py::test_get_decimal_symbol

test_numbers.py::test_get_decimal_symbol

def test_get_decimal_symbol():
>       assert numbers.get_decimal_symbol('en_US') == '.'
E       AssertionError: assert None == '.'
E        +  where None = ('en_US')
E        +    where  = numbers.get_decimal_symbol

tests/test_numbers.py:339: AssertionError

test_numbers.py::test_get_plus_sign_symbol

test_numbers.py::test_get_plus_sign_symbol

def test_get_plus_sign_symbol():
>       assert numbers.get_plus_sign_symbol('en_US') == '+'
E       AssertionError: assert None == '+'
E        +  where None = ('en_US')
E        +    where  = numbers.get_plus_sign_symbol

tests/test_numbers.py:350: AssertionError

test_numbers.py::test_get_minus_sign_symbol

test_numbers.py::test_get_minus_sign_symbol

def test_get_minus_sign_symbol():
>       assert numbers.get_minus_sign_symbol('en_US') == '-'
E       AssertionError: assert None == '-'
E        +  where None = ('en_US')
E        +    where  = numbers.get_minus_sign_symbol

tests/test_numbers.py:360: AssertionError

test_numbers.py::test_get_exponential_symbol

test_numbers.py::test_get_exponential_symbol

def test_get_exponential_symbol():
>       assert numbers.get_exponential_symbol('en_US') == 'E'
E       AssertionError: assert None == 'E'
E        +  where None = ('en_US')
E        +    where  = numbers.get_exponential_symbol

tests/test_numbers.py:371: AssertionError

test_numbers.py::test_get_group_symbol

test_numbers.py::test_get_group_symbol

def test_get_group_symbol():
>       assert numbers.get_group_symbol('en_US') == ','
E       AssertionError: assert None == ','
E        +  where None = ('en_US')
E        +    where  = numbers.get_group_symbol

tests/test_numbers.py:382: AssertionError

test_numbers.py::test_get_infinity_symbol

test_numbers.py::test_get_infinity_symbol

def test_get_infinity_symbol():
>       assert numbers.get_infinity_symbol('en_US') == '∞'
E       AssertionError: assert None == '∞'
E        +  where None = ('en_US')
E        +    where  = numbers.get_infinity_symbol

tests/test_numbers.py:392: AssertionError

test_numbers.py::test_decimal_precision

test_numbers.py::test_decimal_precision

def test_decimal_precision():
>       assert get_decimal_precision(decimal.Decimal('0.110')) == 2
E       AssertionError: assert None == 2
E        +  where None = get_decimal_precision(Decimal('0.110'))
E        +    where Decimal('0.110') = ('0.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:399: AssertionError

test_numbers.py::test_format_decimal

test_numbers.py::test_format_decimal

def test_format_decimal():
>       assert numbers.format_decimal(1099, locale='en_US') == '1,099'
E       AssertionError: assert None == '1,099'
E        +  where None = (1099, locale='en_US')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:405: AssertionError

test_numbers.py::test_format_decimal_precision[10000-10,000]

test_numbers.py::test_format_decimal_precision[10000-10,000]

input_value = '10000', expected_value = '10,000'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '10,000'
E        +  where None = (Decimal('10000'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('10000') = ('10000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1-1]

test_numbers.py::test_format_decimal_precision[1-1]

input_value = '1', expected_value = '1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1'
E        +  where None = (Decimal('1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1') = ('1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.0-1]

test_numbers.py::test_format_decimal_precision[1.0-1]

input_value = '1.0', expected_value = '1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1'
E        +  where None = (Decimal('1.0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.0') = ('1.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.1-1.1]

test_numbers.py::test_format_decimal_precision[1.1-1.1]

input_value = '1.1', expected_value = '1.1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1'
E        +  where None = (Decimal('1.1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.1') = ('1.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.11-1.11]

test_numbers.py::test_format_decimal_precision[1.11-1.11]

input_value = '1.11', expected_value = '1.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11'
E        +  where None = (Decimal('1.11'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.11') = ('1.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.110-1.11]

test_numbers.py::test_format_decimal_precision[1.110-1.11]

input_value = '1.110', expected_value = '1.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11'
E        +  where None = (Decimal('1.110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.110') = ('1.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.001-1.001]

test_numbers.py::test_format_decimal_precision[1.001-1.001]

input_value = '1.001', expected_value = '1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001'
E        +  where None = (Decimal('1.001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.001') = ('1.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[1.00100-1.001]

test_numbers.py::test_format_decimal_precision[1.00100-1.001]

input_value = '1.00100', expected_value = '1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001'
E        +  where None = (Decimal('1.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.00100') = ('1.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[01.00100-1.001]

test_numbers.py::test_format_decimal_precision[01.00100-1.001]

input_value = '01.00100', expected_value = '1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001'
E        +  where None = (Decimal('1.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1.00100') = ('01.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[101.00100-101.001]

test_numbers.py::test_format_decimal_precision[101.00100-101.001]

input_value = '101.00100', expected_value = '101.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '101.001'
E        +  where None = (Decimal('101.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('101.00100') = ('101.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[00000-0]

test_numbers.py::test_format_decimal_precision[00000-0]

input_value = '00000', expected_value = '0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0'
E        +  where None = (Decimal('0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0') = ('00000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0-0]

test_numbers.py::test_format_decimal_precision[0-0]

input_value = '0', expected_value = '0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0'
E        +  where None = (Decimal('0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0') = ('0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.0-0]

test_numbers.py::test_format_decimal_precision[0.0-0]

input_value = '0.0', expected_value = '0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0'
E        +  where None = (Decimal('0.0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.0') = ('0.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.1-0.1]

test_numbers.py::test_format_decimal_precision[0.1-0.1]

input_value = '0.1', expected_value = '0.1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.1'
E        +  where None = (Decimal('0.1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.1') = ('0.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.11-0.11]

test_numbers.py::test_format_decimal_precision[0.11-0.11]

input_value = '0.11', expected_value = '0.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.11'
E        +  where None = (Decimal('0.11'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.11') = ('0.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.110-0.11]

test_numbers.py::test_format_decimal_precision[0.110-0.11]

input_value = '0.110', expected_value = '0.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.11'
E        +  where None = (Decimal('0.110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.110') = ('0.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.001-0.001]

test_numbers.py::test_format_decimal_precision[0.001-0.001]

input_value = '0.001', expected_value = '0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.001'
E        +  where None = (Decimal('0.001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.001') = ('0.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[0.00100-0.001]

test_numbers.py::test_format_decimal_precision[0.00100-0.001]

input_value = '0.00100', expected_value = '0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.001'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.00100') = ('0.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[00.00100-0.001]

test_numbers.py::test_format_decimal_precision[00.00100-0.001]

input_value = '00.00100', expected_value = '0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.001'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.00100') = ('00.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_precision[000.00100-0.001]

test_numbers.py::test_format_decimal_precision[000.00100-0.001]

input_value = '000.00100', expected_value = '0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '10,000'),
        ('1', '1'),
        ('1.0', '1'),
        ('1.1', '1.1'),
        ('1.11', '1.11'),
        ('1.110', '1.11'),
        ('1.001', '1.001'),
        ('1.00100', '1.001'),
        ('01.00100', '1.001'),
        ('101.00100', '101.001'),
        ('00000', '0'),
        ('0', '0'),
        ('0.0', '0'),
        ('0.1', '0.1'),
        ('0.11', '0.11'),
        ('0.110', '0.11'),
        ('0.001', '0.001'),
        ('0.00100', '0.001'),
        ('00.00100', '0.001'),
        ('000.00100', '0.001'),
    ])
    def test_format_decimal_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_decimal(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.001'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('0.00100') = ('000.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:449: AssertionError

test_numbers.py::test_format_decimal_quantization

test_numbers.py::test_format_decimal_quantization

def test_format_decimal_quantization():
        # Test all locales.
        for locale_code in localedata.locale_identifiers():
            assert numbers.format_decimal(
>               '0.9999999999', locale=locale_code, decimal_quantization=False).endswith('9999999999') is True
E           AttributeError: 'NoneType' object has no attribute 'endswith'

tests/test_numbers.py:457: AttributeError

test_numbers.py::test_format_currency

test_numbers.py::test_format_currency

def test_format_currency():
>       assert (numbers.format_currency(1099.98, 'USD', locale='en_US')
                == '$1,099.98')
E       AssertionError: assert None == '$1,099.98'
E        +  where None = (1099.98, 'USD', locale='en_US')
E        +    where  = numbers.format_currency

tests/test_numbers.py:461: AssertionError

test_numbers.py::test_format_currency_format_type

test_numbers.py::test_format_currency_format_type

def test_format_currency_format_type():
>       assert (numbers.format_currency(1099.98, 'USD', locale='en_US',
                                        format_type="standard")
                == '$1,099.98')
E       AssertionError: assert None == '$1,099.98'
E        +  where None = (1099.98, 'USD', locale='en_US', format_type='standard')
E        +    where  = numbers.format_currency

tests/test_numbers.py:490: AssertionError

test_numbers.py::test_format_compact_currency

test_numbers.py::test_format_compact_currency

def test_format_compact_currency():
>       assert numbers.format_compact_currency(1, 'USD', locale='en_US', format_type="short") == '$1'
E       AssertionError: assert None == '$1'
E        +  where None = (1, 'USD', locale='en_US', format_type='short')
E        +    where  = numbers.format_compact_currency

tests/test_numbers.py:522: AssertionError

test_numbers.py::test_format_compact_currency_invalid_format_type

test_numbers.py::test_format_compact_currency_invalid_format_type

def test_format_compact_currency_invalid_format_type():
>       with pytest.raises(numbers.UnknownCurrencyFormatError):
E       Failed: DID NOT RAISE 

tests/test_numbers.py:539: Failed

test_numbers.py::test_format_currency_precision[10000-$10,000.00]

test_numbers.py::test_format_currency_precision[10000-$10,000.00]

input_value = '10000', expected_value = '$10,000.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$10,000.00'
E        +  where None = (Decimal('10000'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('10000') = ('10000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1-$1.00]

test_numbers.py::test_format_currency_precision[1-$1.00]

input_value = '1', expected_value = '$1.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.00'
E        +  where None = (Decimal('1'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1') = ('1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.0-$1.00]

test_numbers.py::test_format_currency_precision[1.0-$1.00]

input_value = '1.0', expected_value = '$1.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.00'
E        +  where None = (Decimal('1.0'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.0') = ('1.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.1-$1.10]

test_numbers.py::test_format_currency_precision[1.1-$1.10]

input_value = '1.1', expected_value = '$1.10'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.10'
E        +  where None = (Decimal('1.1'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.1') = ('1.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.11-$1.11]

test_numbers.py::test_format_currency_precision[1.11-$1.11]

input_value = '1.11', expected_value = '$1.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.11'
E        +  where None = (Decimal('1.11'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.11') = ('1.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.110-$1.11]

test_numbers.py::test_format_currency_precision[1.110-$1.11]

input_value = '1.110', expected_value = '$1.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.11'
E        +  where None = (Decimal('1.110'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.110') = ('1.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.001-$1.001]

test_numbers.py::test_format_currency_precision[1.001-$1.001]

input_value = '1.001', expected_value = '$1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.001'
E        +  where None = (Decimal('1.001'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.001') = ('1.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[1.00100-$1.001]

test_numbers.py::test_format_currency_precision[1.00100-$1.001]

input_value = '1.00100', expected_value = '$1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.001'
E        +  where None = (Decimal('1.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.00100') = ('1.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[01.00100-$1.001]

test_numbers.py::test_format_currency_precision[01.00100-$1.001]

input_value = '01.00100', expected_value = '$1.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$1.001'
E        +  where None = (Decimal('1.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('1.00100') = ('01.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[101.00100-$101.001]

test_numbers.py::test_format_currency_precision[101.00100-$101.001]

input_value = '101.00100', expected_value = '$101.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$101.001'
E        +  where None = (Decimal('101.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('101.00100') = ('101.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[00000-$0.00]

test_numbers.py::test_format_currency_precision[00000-$0.00]

input_value = '00000', expected_value = '$0.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.00'
E        +  where None = (Decimal('0'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0') = ('00000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0-$0.00]

test_numbers.py::test_format_currency_precision[0-$0.00]

input_value = '0', expected_value = '$0.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.00'
E        +  where None = (Decimal('0'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0') = ('0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.0-$0.00]

test_numbers.py::test_format_currency_precision[0.0-$0.00]

input_value = '0.0', expected_value = '$0.00'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.00'
E        +  where None = (Decimal('0.0'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.0') = ('0.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.1-$0.10]

test_numbers.py::test_format_currency_precision[0.1-$0.10]

input_value = '0.1', expected_value = '$0.10'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.10'
E        +  where None = (Decimal('0.1'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.1') = ('0.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.11-$0.11]

test_numbers.py::test_format_currency_precision[0.11-$0.11]

input_value = '0.11', expected_value = '$0.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.11'
E        +  where None = (Decimal('0.11'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.11') = ('0.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.110-$0.11]

test_numbers.py::test_format_currency_precision[0.110-$0.11]

input_value = '0.110', expected_value = '$0.11'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.11'
E        +  where None = (Decimal('0.110'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.110') = ('0.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.001-$0.001]

test_numbers.py::test_format_currency_precision[0.001-$0.001]

input_value = '0.001', expected_value = '$0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.001'
E        +  where None = (Decimal('0.001'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.001') = ('0.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[0.00100-$0.001]

test_numbers.py::test_format_currency_precision[0.00100-$0.001]

input_value = '0.00100', expected_value = '$0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.001'
E        +  where None = (Decimal('0.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.00100') = ('0.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[00.00100-$0.001]

test_numbers.py::test_format_currency_precision[00.00100-$0.001]

input_value = '00.00100', expected_value = '$0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.001'
E        +  where None = (Decimal('0.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.00100') = ('00.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_precision[000.00100-$0.001]

test_numbers.py::test_format_currency_precision[000.00100-$0.001]

input_value = '000.00100', expected_value = '$0.001'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '$10,000.00'),
        ('1', '$1.00'),
        ('1.0', '$1.00'),
        ('1.1', '$1.10'),
        ('1.11', '$1.11'),
        ('1.110', '$1.11'),
        ('1.001', '$1.001'),
        ('1.00100', '$1.001'),
        ('01.00100', '$1.001'),
        ('101.00100', '$101.001'),
        ('00000', '$0.00'),
        ('0', '$0.00'),
        ('0.0', '$0.00'),
        ('0.1', '$0.10'),
        ('0.11', '$0.11'),
        ('0.110', '$0.11'),
        ('0.001', '$0.001'),
        ('0.00100', '$0.001'),
        ('00.00100', '$0.001'),
        ('000.00100', '$0.001'),
    ])
    def test_format_currency_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_currency(
            decimal.Decimal(input_value),
            currency='USD',
            locale='en_US',
            decimal_quantization=False,
        ) == expected_value
E       AssertionError: assert None == '$0.001'
E        +  where None = (Decimal('0.00100'), currency='USD', locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_currency
E        +    and   Decimal('0.00100') = ('000.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:567: AssertionError

test_numbers.py::test_format_currency_quantization

test_numbers.py::test_format_currency_quantization

def test_format_currency_quantization():
        # Test all locales.
        for locale_code in localedata.locale_identifiers():
            assert numbers.format_currency(
>               '0.9999999999', 'USD', locale=locale_code, decimal_quantization=False).find('9999999999') > -1
E           AttributeError: 'NoneType' object has no attribute 'find'

tests/test_numbers.py:579: AttributeError

test_numbers.py::test_format_currency_long_display_name

test_numbers.py::test_format_currency_long_display_name

def test_format_currency_long_display_name():
>       assert (numbers.format_currency(1099.98, 'USD', locale='en_US', format_type='name')
                == '1,099.98 US dollars')
E       AssertionError: assert None == '1,099.98 US dollars'
E        +  where None = (1099.98, 'USD', locale='en_US', format_type='name')
E        +    where  = numbers.format_currency

tests/test_numbers.py:583: AssertionError

test_numbers.py::test_format_currency_long_display_name_all

test_numbers.py::test_format_currency_long_display_name_all

def test_format_currency_long_display_name_all():
        for locale_code in localedata.locale_identifiers():
            assert numbers.format_currency(
>               1, 'USD', locale=locale_code, format_type='name').find('1') > -1
E           AttributeError: 'NoneType' object has no attribute 'find'

tests/test_numbers.py:617: AttributeError

test_numbers.py::test_format_currency_long_display_name_custom_format

test_numbers.py::test_format_currency_long_display_name_custom_format

def test_format_currency_long_display_name_custom_format():
>       assert (numbers.format_currency(1099.98, 'USD', locale='en_US',
                                        format_type='name', format='##0')
                == '1099.98 US dollars')
E       AssertionError: assert None == '1099.98 US dollars'
E        +  where None = (1099.98, 'USD', locale='en_US', format_type='name', format='##0')
E        +    where  = numbers.format_currency

tests/test_numbers.py:623: AssertionError

test_numbers.py::test_format_percent

test_numbers.py::test_format_percent

def test_format_percent():
>       assert numbers.format_percent(0.34, locale='en_US') == '34%'
E       AssertionError: assert None == '34%'
E        +  where None = (0.34, locale='en_US')
E        +    where  = numbers.format_percent

tests/test_numbers.py:633: AssertionError

test_numbers.py::test_format_percent_precision[100-10,000%]

test_numbers.py::test_format_percent_precision[100-10,000%]

input_value = '100', expected_value = '10,000%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '10,000%'
E        +  where None = (Decimal('100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('100') = ('100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.01-1%0]

test_numbers.py::test_format_percent_precision[0.01-1%0]

input_value = '0.01', expected_value = '1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1%'
E        +  where None = (Decimal('0.01'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.01') = ('0.01')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.010-1%]

test_numbers.py::test_format_percent_precision[0.010-1%]

input_value = '0.010', expected_value = '1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1%'
E        +  where None = (Decimal('0.010'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.010') = ('0.010')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.011-1.1%0]

test_numbers.py::test_format_percent_precision[0.011-1.1%0]

input_value = '0.011', expected_value = '1.1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1%'
E        +  where None = (Decimal('0.011'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.011') = ('0.011')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.0111-1.11%]

test_numbers.py::test_format_percent_precision[0.0111-1.11%]

input_value = '0.0111', expected_value = '1.11%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11%'
E        +  where None = (Decimal('0.0111'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.0111') = ('0.0111')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.01110-1.11%]

test_numbers.py::test_format_percent_precision[0.01110-1.11%]

input_value = '0.01110', expected_value = '1.11%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11%'
E        +  where None = (Decimal('0.01110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.01110') = ('0.01110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.01001-1.001%]

test_numbers.py::test_format_percent_precision[0.01001-1.001%]

input_value = '0.01001', expected_value = '1.001%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001%'
E        +  where None = (Decimal('0.01001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.01001') = ('0.01001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.0100100-1.001%]

test_numbers.py::test_format_percent_precision[0.0100100-1.001%]

input_value = '0.0100100', expected_value = '1.001%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001%'
E        +  where None = (Decimal('0.0100100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.0100100') = ('0.0100100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.010100100-1.01001%]

test_numbers.py::test_format_percent_precision[0.010100100-1.01001%]

input_value = '0.010100100', expected_value = '1.01001%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.01001%'
E        +  where None = (Decimal('0.010100100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.010100100') = ('0.010100100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.000000-0%]

test_numbers.py::test_format_percent_precision[0.000000-0%]

input_value = '0.000000', expected_value = '0%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0%'
E        +  where None = (Decimal('0.000000'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.000000') = ('0.000000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0-0%]

test_numbers.py::test_format_percent_precision[0-0%]

input_value = '0', expected_value = '0%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0%'
E        +  where None = (Decimal('0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0') = ('0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.00-0%]

test_numbers.py::test_format_percent_precision[0.00-0%]

input_value = '0.00', expected_value = '0%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0%'
E        +  where None = (Decimal('0.00'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.00') = ('0.00')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.01-1%1]

test_numbers.py::test_format_percent_precision[0.01-1%1]

input_value = '0.01', expected_value = '1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1%'
E        +  where None = (Decimal('0.01'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.01') = ('0.01')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.011-1.1%1]

test_numbers.py::test_format_percent_precision[0.011-1.1%1]

input_value = '0.011', expected_value = '1.1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1%'
E        +  where None = (Decimal('0.011'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.011') = ('0.011')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.0110-1.1%]

test_numbers.py::test_format_percent_precision[0.0110-1.1%]

input_value = '0.0110', expected_value = '1.1%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1%'
E        +  where None = (Decimal('0.0110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.0110') = ('0.0110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.0001-0.01%]

test_numbers.py::test_format_percent_precision[0.0001-0.01%]

input_value = '0.0001', expected_value = '0.01%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.01%'
E        +  where None = (Decimal('0.0001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.0001') = ('0.0001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.000100-0.01%]

test_numbers.py::test_format_percent_precision[0.000100-0.01%]

input_value = '0.000100', expected_value = '0.01%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.01%'
E        +  where None = (Decimal('0.000100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.000100') = ('0.000100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.0000100-0.001%]

test_numbers.py::test_format_percent_precision[0.0000100-0.001%]

input_value = '0.0000100', expected_value = '0.001%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.001%'
E        +  where None = (Decimal('0.0000100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.0000100') = ('0.0000100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_precision[0.00000100-0.0001%]

test_numbers.py::test_format_percent_precision[0.00000100-0.0001%]

input_value = '0.00000100', expected_value = '0.0001%'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('100', '10,000%'),
        ('0.01', '1%'),
        ('0.010', '1%'),
        ('0.011', '1.1%'),
        ('0.0111', '1.11%'),
        ('0.01110', '1.11%'),
        ('0.01001', '1.001%'),
        ('0.0100100', '1.001%'),
        ('0.010100100', '1.01001%'),
        ('0.000000', '0%'),
        ('0', '0%'),
        ('0.00', '0%'),
        ('0.01', '1%'),
        ('0.011', '1.1%'),
        ('0.0110', '1.1%'),
        ('0.0001', '0.01%'),
        ('0.000100', '0.01%'),
        ('0.0000100', '0.001%'),
        ('0.00000100', '0.0001%'),
    ])
    def test_format_percent_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_percent(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0.0001%'
E        +  where None = (Decimal('0.00000100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_percent
E        +    and   Decimal('0.00000100') = ('0.00000100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:670: AssertionError

test_numbers.py::test_format_percent_quantization

test_numbers.py::test_format_percent_quantization

def test_format_percent_quantization():
        # Test all locales.
        for locale_code in localedata.locale_identifiers():
            assert numbers.format_percent(
>               '0.9999999999', locale=locale_code, decimal_quantization=False).find('99999999') > -1
E           AttributeError: 'NoneType' object has no attribute 'find'

tests/test_numbers.py:678: AttributeError

test_numbers.py::test_format_scientific

test_numbers.py::test_format_scientific

def test_format_scientific():
>       assert numbers.format_scientific(10000, locale='en_US') == '1E4'
E       AssertionError: assert None == '1E4'
E        +  where None = (10000, locale='en_US')
E        +    where  = numbers.format_scientific

tests/test_numbers.py:682: AssertionError

test_numbers.py::test_default_scientific_format

test_numbers.py::test_default_scientific_format

def test_default_scientific_format():
        """ Check the scientific format method auto-correct the rendering pattern
        in case of a missing fractional part.
        """
>       assert numbers.format_scientific(12345, locale='en_US') == '1.2345E4'
E       AssertionError: assert None == '1.2345E4'
E        +  where None = (12345, locale='en_US')
E        +    where  = numbers.format_scientific

tests/test_numbers.py:699: AssertionError

test_numbers.py::test_format_scientific_precision[10000-1E4]

test_numbers.py::test_format_scientific_precision[10000-1E4]

input_value = '10000', expected_value = '1E4'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E4'
E        +  where None = (Decimal('10000'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('10000') = ('10000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1-1E0]

test_numbers.py::test_format_scientific_precision[1-1E0]

input_value = '1', expected_value = '1E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E0'
E        +  where None = (Decimal('1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1') = ('1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.0-1E0]

test_numbers.py::test_format_scientific_precision[1.0-1E0]

input_value = '1.0', expected_value = '1E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E0'
E        +  where None = (Decimal('1.0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.0') = ('1.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.1-1.1E0]

test_numbers.py::test_format_scientific_precision[1.1-1.1E0]

input_value = '1.1', expected_value = '1.1E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1E0'
E        +  where None = (Decimal('1.1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.1') = ('1.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.11-1.11E0]

test_numbers.py::test_format_scientific_precision[1.11-1.11E0]

input_value = '1.11', expected_value = '1.11E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11E0'
E        +  where None = (Decimal('1.11'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.11') = ('1.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.110-1.11E0]

test_numbers.py::test_format_scientific_precision[1.110-1.11E0]

input_value = '1.110', expected_value = '1.11E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.11E0'
E        +  where None = (Decimal('1.110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.110') = ('1.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.001-1.001E0]

test_numbers.py::test_format_scientific_precision[1.001-1.001E0]

input_value = '1.001', expected_value = '1.001E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001E0'
E        +  where None = (Decimal('1.001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.001') = ('1.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[1.00100-1.001E0]

test_numbers.py::test_format_scientific_precision[1.00100-1.001E0]

input_value = '1.00100', expected_value = '1.001E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001E0'
E        +  where None = (Decimal('1.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.00100') = ('1.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[01.00100-1.001E0]

test_numbers.py::test_format_scientific_precision[01.00100-1.001E0]

input_value = '01.00100', expected_value = '1.001E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.001E0'
E        +  where None = (Decimal('1.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('1.00100') = ('01.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[101.00100-1.01001E2]

test_numbers.py::test_format_scientific_precision[101.00100-1.01001E2]

input_value = '101.00100', expected_value = '1.01001E2'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.01001E2'
E        +  where None = (Decimal('101.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('101.00100') = ('101.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[00000-0E0]

test_numbers.py::test_format_scientific_precision[00000-0E0]

input_value = '00000', expected_value = '0E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0E0'
E        +  where None = (Decimal('0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0') = ('00000')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0-0E0]

test_numbers.py::test_format_scientific_precision[0-0E0]

input_value = '0', expected_value = '0E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0E0'
E        +  where None = (Decimal('0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0') = ('0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.0-0E0]

test_numbers.py::test_format_scientific_precision[0.0-0E0]

input_value = '0.0', expected_value = '0E0'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '0E0'
E        +  where None = (Decimal('0.0'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.0') = ('0.0')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.1-1E-1]

test_numbers.py::test_format_scientific_precision[0.1-1E-1]

input_value = '0.1', expected_value = '1E-1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E-1'
E        +  where None = (Decimal('0.1'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.1') = ('0.1')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.11-1.1E-1]

test_numbers.py::test_format_scientific_precision[0.11-1.1E-1]

input_value = '0.11', expected_value = '1.1E-1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1E-1'
E        +  where None = (Decimal('0.11'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.11') = ('0.11')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.110-1.1E-1]

test_numbers.py::test_format_scientific_precision[0.110-1.1E-1]

input_value = '0.110', expected_value = '1.1E-1'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1.1E-1'
E        +  where None = (Decimal('0.110'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.110') = ('0.110')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.001-1E-3]

test_numbers.py::test_format_scientific_precision[0.001-1E-3]

input_value = '0.001', expected_value = '1E-3'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E-3'
E        +  where None = (Decimal('0.001'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.001') = ('0.001')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[0.00100-1E-3]

test_numbers.py::test_format_scientific_precision[0.00100-1E-3]

input_value = '0.00100', expected_value = '1E-3'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E-3'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.00100') = ('0.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[00.00100-1E-3]

test_numbers.py::test_format_scientific_precision[00.00100-1E-3]

input_value = '00.00100', expected_value = '1E-3'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E-3'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.00100') = ('00.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_precision[000.00100-1E-3]

test_numbers.py::test_format_scientific_precision[000.00100-1E-3]

input_value = '000.00100', expected_value = '1E-3'

    @pytest.mark.parametrize('input_value, expected_value', [
        ('10000', '1E4'),
        ('1', '1E0'),
        ('1.0', '1E0'),
        ('1.1', '1.1E0'),
        ('1.11', '1.11E0'),
        ('1.110', '1.11E0'),
        ('1.001', '1.001E0'),
        ('1.00100', '1.001E0'),
        ('01.00100', '1.001E0'),
        ('101.00100', '1.01001E2'),
        ('00000', '0E0'),
        ('0', '0E0'),
        ('0.0', '0E0'),
        ('0.1', '1E-1'),
        ('0.11', '1.1E-1'),
        ('0.110', '1.1E-1'),
        ('0.001', '1E-3'),
        ('0.00100', '1E-3'),
        ('00.00100', '1E-3'),
        ('000.00100', '1E-3'),
    ])
    def test_format_scientific_precision(input_value, expected_value):
        # Test precision conservation.
>       assert numbers.format_scientific(
            decimal.Decimal(input_value), locale='en_US', decimal_quantization=False) == expected_value
E       AssertionError: assert None == '1E-3'
E        +  where None = (Decimal('0.00100'), locale='en_US', decimal_quantization=False)
E        +    where  = numbers.format_scientific
E        +    and   Decimal('0.00100') = ('000.00100')
E        +      where  = decimal.Decimal

tests/test_numbers.py:729: AssertionError

test_numbers.py::test_format_scientific_quantization

test_numbers.py::test_format_scientific_quantization

def test_format_scientific_quantization():
        # Test all locales.
        for locale_code in localedata.locale_identifiers():
            assert numbers.format_scientific(
>               '0.9999999999', locale=locale_code, decimal_quantization=False).find('999999999') > -1
E           AttributeError: 'NoneType' object has no attribute 'find'

tests/test_numbers.py:737: AttributeError

test_numbers.py::test_parse_number

test_numbers.py::test_parse_number

def test_parse_number():
>       assert numbers.parse_number('1,099', locale='en_US') == 1099
E       AssertionError: assert None == 1099
E        +  where None = ('1,099', locale='en_US')
E        +    where  = numbers.parse_number

tests/test_numbers.py:741: AssertionError

test_numbers.py::test_parse_decimal

test_numbers.py::test_parse_decimal

def test_parse_decimal():
>       assert (numbers.parse_decimal('1,099.98', locale='en_US')
                == decimal.Decimal('1099.98'))
E       AssertionError: assert None == Decimal('1099.98')
E        +  where None = ('1,099.98', locale='en_US')
E        +    where  = numbers.parse_decimal
E        +  and   Decimal('1099.98') = ('1099.98')
E        +    where  = decimal.Decimal

tests/test_numbers.py:753: AssertionError

test_numbers.py::test_parse_grouping

test_numbers.py::test_parse_grouping

def test_parse_grouping():
>       assert numbers.parse_grouping('##') == (1000, 1000)
E       AssertionError: assert None == (1000, 1000)
E        +  where None = ('##')
E        +    where  = numbers.parse_grouping

tests/test_numbers.py:763: AssertionError

test_numbers.py::test_parse_pattern

test_numbers.py::test_parse_pattern

def test_parse_pattern():

        # Original pattern is preserved
        np = numbers.parse_pattern('¤#,##0.00')
>       assert np.pattern == '¤#,##0.00'
E       AttributeError: 'NoneType' object has no attribute 'pattern'

tests/test_numbers.py:772: AttributeError

test_numbers.py::test_parse_pattern_negative

test_numbers.py::test_parse_pattern_negative

def test_parse_pattern_negative():

        # No negative format specified
        np = numbers.parse_pattern('¤#,##0.00')
>       assert np.prefix == ('¤', '-¤')
E       AttributeError: 'NoneType' object has no attribute 'prefix'

tests/test_numbers.py:791: AttributeError

test_numbers.py::test_numberpattern_repr

test_numbers.py::test_numberpattern_repr

def test_numberpattern_repr():
        """repr() outputs the pattern string"""

        # This implementation looks a bit funny, but that's cause strings are
        # repr'd differently in Python 2 vs 3 and this test runs under both.
        format = '¤#,##0.00;(¤#,##0.00)'
        np = numbers.parse_pattern(format)
>       assert repr(format) in repr(np)
E       assert "'¤#,##0.00;(¤#,##0.00)'" in 'None'
E        +  where "'¤#,##0.00;(¤#,##0.00)'" = repr('¤#,##0.00;(¤#,##0.00)')
E        +  and   'None' = repr(None)

tests/test_numbers.py:812: AssertionError

test_numbers.py::test_parse_static_pattern

test_numbers.py::test_parse_static_pattern

def test_parse_static_pattern():
>       assert numbers.parse_pattern('Kun')  # in the So locale in CLDR 30
E       AssertionError: assert None
E        +  where None = ('Kun')
E        +    where  = numbers.parse_pattern

tests/test_numbers.py:816: AssertionError

test_numbers.py::test_parse_decimal_nbsp_heuristics

test_numbers.py::test_parse_decimal_nbsp_heuristics

def test_parse_decimal_nbsp_heuristics():
        # Re https://github.com/python-babel/babel/issues/637 –
        #    for locales (of which there are many) that use U+00A0 as the group
        #    separator in numbers, it's reasonable to assume that input strings
        #    with plain spaces actually should have U+00A0s instead.
        #    This heuristic is only applied when strict=False.
        n = decimal.Decimal("12345.123")
>       assert numbers.parse_decimal("12 345.123", locale="fi") == n
E       AssertionError: assert None == Decimal('12345.123')
E        +  where None = ('12 345.123', locale='fi')
E        +    where  = numbers.parse_decimal

tests/test_numbers.py:827: AssertionError

test_numbers.py::test_very_small_decimal_no_quantization

test_numbers.py::test_very_small_decimal_no_quantization

def test_very_small_decimal_no_quantization():
>       assert numbers.format_decimal(decimal.Decimal('1E-7'), locale='en', decimal_quantization=False) == '0.0000001'
E       AssertionError: assert None == '0.0000001'
E        +  where None = (Decimal('1E-7'), locale='en', decimal_quantization=False)
E        +    where  = numbers.format_decimal
E        +    and   Decimal('1E-7') = ('1E-7')
E        +      where  = decimal.Decimal

tests/test_numbers.py:832: AssertionError

test_numbers.py::test_single_quotes_in_pattern

test_numbers.py::test_single_quotes_in_pattern

def test_single_quotes_in_pattern():
>       assert numbers.format_decimal(123, "'@0.#'00'@01'", locale='en') == '@0.#120@01'
E       assert None == '@0.#120@01'
E        +  where None = (123, "'@0.#'00'@01'", locale='en')
E        +    where  = numbers.format_decimal

tests/test_numbers.py:836: AssertionError

test_plural.py::test_plural_rule

test_plural.py::test_plural_rule

def test_plural_rule():
>       rule = plural.PluralRule({'one': 'n is 1'})

tests/test_plural.py:23: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'n is 1'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_rule_operands_i

test_plural.py::test_plural_rule_operands_i

def test_plural_rule_operands_i():
>       rule = plural.PluralRule({'one': 'i is 1'})

tests/test_plural.py:32: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'i is 1'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_rule_operands_v

test_plural.py::test_plural_rule_operands_v

def test_plural_rule_operands_v():
>       rule = plural.PluralRule({'one': 'v is 2'})

tests/test_plural.py:38: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'v is 2'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_rule_operands_w

test_plural.py::test_plural_rule_operands_w

def test_plural_rule_operands_w():
>       rule = plural.PluralRule({'one': 'w is 2'})

tests/test_plural.py:45: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'w is 2'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_rule_operands_f

test_plural.py::test_plural_rule_operands_f

def test_plural_rule_operands_f():
>       rule = plural.PluralRule({'one': 'f is 20'})

tests/test_plural.py:52: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'f is 20'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_rule_operands_t

test_plural.py::test_plural_rule_operands_t

def test_plural_rule_operands_t():
>       rule = plural.PluralRule({'one': 't = 5'})

tests/test_plural.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 't = 5'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_plural_other_is_ignored

test_plural.py::test_plural_other_is_ignored

def test_plural_other_is_ignored():
>       rule = plural.PluralRule({'one': 'n is 1', 'other': '@integer 2'})

tests/test_plural.py:66: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'n is 1'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_to_javascript

test_plural.py::test_to_javascript

def test_to_javascript():
>       assert (plural.to_javascript({'one': 'n is 1'})
                == "(function(n) { return (n == 1) ? 'one' : 'other'; })")

tests/test_plural.py:71: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:161: in to_javascript
    rule = PluralRule.parse(rule)
babel/plural.py:112: in parse
    return cls(rules)
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'n is 1'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_to_python

test_plural.py::test_to_python

def test_to_python():
>       func = plural.to_python({'one': 'n is 1', 'few': 'n in 2..4'})

tests/test_plural.py:76: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:193: in to_python
    rule = PluralRule.parse(rule)
babel/plural.py:112: in parse
    return cls(rules)
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'n in 2..4'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_to_gettext

test_plural.py::test_to_gettext

def test_to_gettext():
>       assert (plural.to_gettext({'one': 'n is 1', 'two': 'n is 2'})
                == 'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);')

tests/test_plural.py:86: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:220: in to_gettext
    rule = PluralRule.parse(rule)
babel/plural.py:112: in parse
    return cls(rules)
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , string = 'n is 1'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_in_range_list

test_plural.py::test_in_range_list

def test_in_range_list():
        assert plural.in_range_list(1, [(1, 3)])
        assert plural.in_range_list(3, [(1, 3)])
        assert plural.in_range_list(3, [(1, 3), (5, 8)])
>       assert not plural.in_range_list(1.2, [(1, 4)])
E       assert not True
E        +  where True = (1.2, [(1, 4)])
E        +    where  = plural.in_range_list

tests/test_plural.py:94: AssertionError

test_plural.py::test_cldr_modulo

test_plural.py::test_cldr_modulo

def test_cldr_modulo():
>       assert plural.cldr_modulo(-3, 5) == -3
E       assert None == -3
E        +  where None = (-3, 5)
E        +    where  = plural.cldr_modulo

tests/test_plural.py:109: AssertionError

test_plural.py::test_plural_within_rules

test_plural.py::test_plural_within_rules

def test_plural_within_rules():
>       p = plural.PluralRule({'one': 'n is 1', 'few': 'n within 2,4,7..9'})

tests/test_plural.py:115: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/plural.py:91: in __init__
    ast = _Parser(expr).ast
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 
string = 'n within 2,4,7..9'

    def __init__(self, string):
>       self.tokens = tokenize_rule(string)
E       NameError: name 'tokenize_rule' is not defined

babel/plural.py:338: NameError

test_plural.py::test_locales_with_no_plural_rules_have_default

test_plural.py::test_locales_with_no_plural_rules_have_default

def test_locales_with_no_plural_rules_have_default():
        from babel import Locale
>       pf = Locale.parse('ii').plural_form

tests/test_plural.py:138: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = , identifier = 'ii', sep = '_'
resolve_likely_subtags = True

    @classmethod
    def parse(cls, identifier: (str | Locale | None), sep: str='_',
        resolve_likely_subtags: bool=True) ->Locale:
        """Create a `Locale` instance for the given locale identifier.

        >>> l = Locale.parse('de-DE', sep='-')
        >>> l.display_name
        u'Deutsch (Deutschland)'

        If the `identifier` parameter is not a string, but actually a `Locale`
        object, that object is returned:

        >>> Locale.parse(l)
        Locale('de', territory='DE')

        If the `identifier` parameter is neither of these, such as `None`
        e.g. because a default locale identifier could not be determined,
        a `TypeError` is raised:

        >>> Locale.parse(None)
        Traceback (most recent call last):
            ...
        TypeError: ...

        This also can perform resolving of likely subtags which it does
        by default.  This is for instance useful to figure out the most
        likely locale for a territory you can use ``'und'`` as the
        language tag:

        >>> Locale.parse('und_AT')
        Locale('de', territory='AT')

        Modifiers are optional, and always at the end, separated by "@":

        >>> Locale.parse('de_AT@euro')
        Locale('de', territory='AT', modifier='euro')

        :param identifier: the locale identifier string
        :param sep: optional component separator
        :param resolve_likely_subtags: if this is specified then a locale will
                                       have its likely subtag resolved if the
                                       locale otherwise does not exist.  For
                                       instance ``zh_TW`` by itself is not a
                                       locale that exists but Babel can
                                       automatically expand it to the full
                                       form of ``zh_hant_TW``.  Note that this
                                       expansion is only taking place if no
                                       locale exists otherwise.  For instance
                                       there is a locale ``en`` that can exist
                                       by itself.
        :raise `ValueError`: if the string does not appear to be a valid locale
                             identifier
        :raise `UnknownLocaleError`: if no locale data is available for the
                                     requested locale
        :raise `TypeError`: if the identifier is not a string or a `Locale`
        """
        if isinstance(identifier, Locale):
            return identifier
        if not isinstance(identifier, str):
            raise TypeError('Locale identifier must be a string or Locale object')

        parts = parse_locale(identifier, sep)
>       language, territory, script, variant, modifier = parts
E       ValueError: not enough values to unpack (expected 5, got 4)

babel/core.py:277: ValueError

test_plural.py::test_tokenize_well_formed[-tokens0]

test_plural.py::test_tokenize_well_formed[-tokens0]

rule_text = '', tokens = []

    @pytest.mark.parametrize('rule_text,tokens', WELL_FORMED_TOKEN_TESTS)
    def test_tokenize_well_formed(rule_text, tokens):
>       assert plural.tokenize_rule(rule_text) == tokens
E       AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:187: AttributeError

test_plural.py::test_tokenize_well_formed[n = 1-tokens1]

test_plural.py::test_tokenize_well_formed[n = 1-tokens1]

rule_text = 'n = 1', tokens = [('value', '1'), ('symbol', '='), ('word', 'n')]

    @pytest.mark.parametrize('rule_text,tokens', WELL_FORMED_TOKEN_TESTS)
    def test_tokenize_well_formed(rule_text, tokens):
>       assert plural.tokenize_rule(rule_text) == tokens
E       AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:187: AttributeError

test_plural.py::test_tokenize_well_formed[n = 1 @integer 1-tokens2]

test_plural.py::test_tokenize_well_formed[n = 1 @integer 1-tokens2]

rule_text = 'n = 1 @integer 1'
tokens = [('value', '1'), ('symbol', '='), ('word', 'n')]

    @pytest.mark.parametrize('rule_text,tokens', WELL_FORMED_TOKEN_TESTS)
    def test_tokenize_well_formed(rule_text, tokens):
>       assert plural.tokenize_rule(rule_text) == tokens
E       AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:187: AttributeError

test_plural.py::test_tokenize_well_formed[n is 1-tokens3]

test_plural.py::test_tokenize_well_formed[n is 1-tokens3]

rule_text = 'n is 1', tokens = [('value', '1'), ('word', 'is'), ('word', 'n')]

    @pytest.mark.parametrize('rule_text,tokens', WELL_FORMED_TOKEN_TESTS)
    def test_tokenize_well_formed(rule_text, tokens):
>       assert plural.tokenize_rule(rule_text) == tokens
E       AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:187: AttributeError

test_plural.py::test_tokenize_well_formed[n % 100 = 3..10-tokens4]

test_plural.py::test_tokenize_well_formed[n % 100 = 3..10-tokens4]

rule_text = 'n % 100 = 3..10'
tokens = [('value', '10'), ('ellipsis', '..'), ('value', '3'), ('symbol', '='), ('value', '100'), ('symbol', '%'), ...]

    @pytest.mark.parametrize('rule_text,tokens', WELL_FORMED_TOKEN_TESTS)
    def test_tokenize_well_formed(rule_text, tokens):
>       assert plural.tokenize_rule(rule_text) == tokens
E       AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:187: AttributeError

test_plural.py::test_tokenize_malformed[a = 1]

test_plural.py::test_tokenize_malformed[a = 1]

rule_text = 'a = 1'

    @pytest.mark.parametrize('rule_text', MALFORMED_TOKEN_TESTS)
    def test_tokenize_malformed(rule_text):
        with pytest.raises(plural.RuleError):
>           plural.tokenize_rule(rule_text)
E           AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:198: AttributeError

test_plural.py::test_tokenize_malformed[n ! 2]

test_plural.py::test_tokenize_malformed[n ! 2]

rule_text = 'n ! 2'

    @pytest.mark.parametrize('rule_text', MALFORMED_TOKEN_TESTS)
    def test_tokenize_malformed(rule_text):
        with pytest.raises(plural.RuleError):
>           plural.tokenize_rule(rule_text)
E           AttributeError: module 'babel.plural' has no attribute 'tokenize_rule'

tests/test_plural.py:198: AttributeError

test_plural.py::TestNextTokenTestCase::test_empty

test_plural.py::TestNextTokenTestCase::test_empty

self = 

    def test_empty(self):
>       assert not plural.test_next_token([], '')
E       AttributeError: module 'babel.plural' has no attribute 'test_next_token'

tests/test_plural.py:204: AttributeError

test_plural.py::TestNextTokenTestCase::test_type_not_ok_and_value_ok

test_plural.py::TestNextTokenTestCase::test_type_not_ok_and_value_ok

self = 

    def test_type_not_ok_and_value_ok(self):
>       assert not plural.test_next_token([('abc', 'and')], 'word', 'and')
E       AttributeError: module 'babel.plural' has no attribute 'test_next_token'

tests/test_plural.py:216: AttributeError

test_plural.py::TestNextTokenTestCase::test_type_ok_and_no_value

test_plural.py::TestNextTokenTestCase::test_type_ok_and_no_value

self = 

    def test_type_ok_and_no_value(self):
>       assert plural.test_next_token([('word', 'and')], 'word')
E       AttributeError: module 'babel.plural' has no attribute 'test_next_token'

tests/test_plural.py:207: AttributeError

test_plural.py::TestNextTokenTestCase::test_type_ok_and_not_value

test_plural.py::TestNextTokenTestCase::test_type_ok_and_not_value

self = 

    def test_type_ok_and_not_value(self):
>       assert not plural.test_next_token([('word', 'and')], 'word', 'or')
E       AttributeError: module 'babel.plural' has no attribute 'test_next_token'

tests/test_plural.py:210: AttributeError

test_plural.py::TestNextTokenTestCase::test_type_ok_and_value_ok

test_plural.py::TestNextTokenTestCase::test_type_ok_and_value_ok

self = 

    def test_type_ok_and_value_ok(self):
>       assert plural.test_next_token([('word', 'and')], 'word', 'and')
E       AttributeError: module 'babel.plural' has no attribute 'test_next_token'

tests/test_plural.py:213: AttributeError

test_plural.py::PluralRuleParserTestCase::test_and

test_plural.py::PluralRuleParserTestCase::test_and

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_eq_relation

test_plural.py::PluralRuleParserTestCase::test_eq_relation

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_error_when_unexpected_end

test_plural.py::PluralRuleParserTestCase::test_error_when_unexpected_end

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_in_range_relation

test_plural.py::PluralRuleParserTestCase::test_in_range_relation

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_negate

test_plural.py::PluralRuleParserTestCase::test_negate

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_or

test_plural.py::PluralRuleParserTestCase::test_or

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::PluralRuleParserTestCase::test_or_and

test_plural.py::PluralRuleParserTestCase::test_or_and

self = 

    def setUp(self):
>       self.n = plural.ident_node('n')
E       AttributeError: module 'babel.plural' has no attribute 'ident_node'

tests/test_plural.py:235: AttributeError

test_plural.py::test_extract_operands[1-1-1-0-0-0-0]

test_plural.py::test_extract_operands[1-1-1-0-0-0-0]

source = 1, n = 1, i = 1, v = 0, w = 0, f = 0, t = 0

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source1-1.0-1-1-0-0-0]

test_plural.py::test_extract_operands[source1-1.0-1-1-0-0-0]

source = Decimal('1.0'), n = '1.0', i = 1, v = 1, w = 0, f = 0, t = 0

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source2-1.00-1-2-0-0-0]

test_plural.py::test_extract_operands[source2-1.00-1-2-0-0-0]

source = Decimal('1.00'), n = '1.00', i = 1, v = 2, w = 0, f = 0, t = 0

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source3-1.3-1-1-1-3-3]

test_plural.py::test_extract_operands[source3-1.3-1-1-1-3-3]

source = Decimal('1.3'), n = '1.3', i = 1, v = 1, w = 1, f = 3, t = 3

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source4-1.30-1-2-1-30-3]

test_plural.py::test_extract_operands[source4-1.30-1-2-1-30-3]

source = Decimal('1.30'), n = '1.30', i = 1, v = 2, w = 1, f = 30, t = 3

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source5-1.03-1-2-2-3-3]

test_plural.py::test_extract_operands[source5-1.03-1-2-2-3-3]

source = Decimal('1.03'), n = '1.03', i = 1, v = 2, w = 2, f = 3, t = 3

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[source6-1.230-1-3-2-230-23]

test_plural.py::test_extract_operands[source6-1.230-1-3-2-230-23]

source = Decimal('1.230'), n = '1.230', i = 1, v = 3, w = 2, f = 230, t = 23

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[-1-1-1-0-0-0-0]

test_plural.py::test_extract_operands[-1-1-1-0-0-0-0]

source = -1, n = 1, i = 1, v = 0, w = 0, f = 0, t = 0

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_extract_operands[1.3-1.3-1-1-1-3-3]

test_plural.py::test_extract_operands[1.3-1.3-1-1-1-3-3]

source = 1.3, n = '1.3', i = 1, v = 1, w = 1, f = 3, t = 3

    @pytest.mark.parametrize('source,n,i,v,w,f,t', EXTRACT_OPERANDS_TESTS)
    def test_extract_operands(source, n, i, v, w, f, t):
>       e_n, e_i, e_v, e_w, e_f, e_t, e_c, e_e = plural.extract_operands(source)
E       TypeError: cannot unpack non-iterable NoneType object

tests/test_plural.py:288: TypeError

test_plural.py::test_gettext_compilation[ru]

test_plural.py::test_gettext_compilation[ru]

locale = 'ru'

    @pytest.mark.parametrize('locale', ('ru', 'pl'))
    def test_gettext_compilation(locale):
        # Test that new plural form elements introduced in recent CLDR versions
        # are compiled "down" to `n` when emitting Gettext rules.
>       ru_rules = localedata.load(locale)['plural_form'].rules

tests/test_plural.py:303: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/localedata.py:127: in load
    data = pickle.load(fileobj)
babel/dates.py:29: in 
    from babel import localtime
babel/localtime/__init__.py:18: in 
    from babel.localtime._unix import _get_localzone
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    import datetime
    import os
    import re
>   from babel.localtime._helpers import _get_tzinfo, _get_tzinfo_from_file, _get_tzinfo_or_raise
E   ImportError: cannot import name '_get_tzinfo_from_file' from 'babel.localtime._helpers' (/testbed/babel/localtime/_helpers.py)

babel/localtime/_unix.py:4: ImportError

test_plural.py::test_gettext_compilation[pl]

test_plural.py::test_gettext_compilation[pl]

locale = 'pl'

    @pytest.mark.parametrize('locale', ('ru', 'pl'))
    def test_gettext_compilation(locale):
        # Test that new plural form elements introduced in recent CLDR versions
        # are compiled "down" to `n` when emitting Gettext rules.
>       ru_rules = localedata.load(locale)['plural_form'].rules

tests/test_plural.py:303: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/localedata.py:127: in load
    data = pickle.load(fileobj)
babel/dates.py:29: in 
    from babel import localtime
babel/localtime/__init__.py:18: in 
    from babel.localtime._unix import _get_localzone
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    import datetime
    import os
    import re
>   from babel.localtime._helpers import _get_tzinfo, _get_tzinfo_from_file, _get_tzinfo_or_raise
E   ImportError: cannot import name '_get_tzinfo_from_file' from 'babel.localtime._helpers' (/testbed/babel/localtime/_helpers.py)

babel/localtime/_unix.py:4: ImportError

Patch diff

diff --git a/babel/core.py b/babel/core.py
index 44904d4..af62195 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -63,7 +63,12 @@ def get_global(key: _GLOBAL_KEY) ->Mapping[str, Any]:

     :param key: the data key
     """
-    pass
+    global _global_data
+    if _global_data is None:
+        dirname = os.path.join(os.path.dirname(__file__), 'global.dat')
+        with open(dirname, 'rb') as f:
+            _global_data = pickle.load(f)
+    return _global_data[key]


 LOCALE_ALIASES = {'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca':
@@ -174,7 +179,10 @@ class Locale:
         :param category: one of the ``LC_XXX`` environment variable names
         :param aliases: a dictionary of aliases for locale identifiers
         """
-        pass
+        locale_string = default_locale(category, aliases)
+        if locale_string:
+            return cls.parse(locale_string)
+        return None

     @classmethod
     def negotiate(cls, preferred: Iterable[str], available: Iterable[str],
@@ -199,7 +207,10 @@ class Locale:
         :param available: the list of locale identifiers available
         :param aliases: a dictionary of aliases for locale identifiers
         """
-        pass
+        locale_identifier = negotiate_locale(preferred, available, sep, aliases)
+        if locale_identifier:
+            return cls.parse(locale_identifier)
+        return None

     @classmethod
     def parse(cls, identifier: (str | Locale | None), sep: str='_',
@@ -257,7 +268,26 @@ class Locale:
                                      requested locale
         :raise `TypeError`: if the identifier is not a string or a `Locale`
         """
-        pass
+        if isinstance(identifier, Locale):
+            return identifier
+        if not isinstance(identifier, str):
+            raise TypeError('Locale identifier must be a string or Locale object')
+
+        parts = parse_locale(identifier, sep)
+        language, territory, script, variant, modifier = parts
+
+        if resolve_likely_subtags:
+            language, territory, script = cls._resolve_likely_subtags(language, territory, script)
+
+        return cls(language, territory, script, variant, modifier)
+
+    @classmethod
+    def _resolve_likely_subtags(cls, language, territory, script):
+        if language == 'und' and territory:
+            likely_subtags = get_global('likely_subtags')
+            if territory in likely_subtags:
+                language, _, script = likely_subtags[territory].partition('_')
+        return language, territory, script

     def __eq__(self, other: object) ->bool:
         for key in ('language', 'territory', 'script', 'variant', 'modifier'):
@@ -910,7 +940,23 @@ def default_locale(category: (str | None)=None, aliases: Mapping[str, str]=
     :param category: one of the ``LC_XXX`` environment variable names
     :param aliases: a dictionary of aliases for locale identifiers
     """
-    pass
+    varnames = (category, 'LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
+    for name in varnames:
+        if not name:
+            continue
+        locale = os.environ.get(name)
+        if locale:
+            if locale.upper() in ('C', 'POSIX'):
+                return 'en_US_POSIX'
+            if name == 'LANGUAGE' and ':' in locale:
+                # LANGUAGE is a colon-separated list of language codes
+                locale = locale.split(':')[0]
+            if '@' in locale:
+                locale = locale.split('@')[0]
+            if '.' in locale:
+                locale = locale.split('.')[0]
+            return aliases.get(locale, locale)
+    return None


 def negotiate_locale(preferred: Iterable[str], available: Iterable[str],
@@ -960,7 +1006,24 @@ def negotiate_locale(preferred: Iterable[str], available: Iterable[str],
                 strings
     :param aliases: a dictionary of aliases for locale identifiers
     """
-    pass
+    available = [a.lower() for a in available]
+    for locale in preferred:
+        locale = locale.lower()
+        if locale in available:
+            return locale
+        if aliases:
+            alias = aliases.get(locale)
+            if alias:
+                alias = alias.lower()
+                if alias in available:
+                    return alias
+        parts = locale.split(sep)
+        if len(parts) > 1:
+            for i in range(1, len(parts)):
+                partial = sep.join(parts[:-i])
+                if partial in available:
+                    return partial
+    return None


 def parse_locale(identifier: str, sep: str='_') ->(tuple[str, str | None, 
@@ -1020,7 +1083,32 @@ def parse_locale(identifier: str, sep: str='_') ->(tuple[str, str | None,
     :raise `ValueError`: if the string does not appear to be a valid locale
                          identifier
     """
-    pass
+    if '@' in identifier:
+        identifier, modifier = identifier.split('@', 1)
+    else:
+        modifier = None
+
+    parts = identifier.split(sep)
+    lang = parts.pop(0).lower()
+    if not lang.isalpha():
+        raise ValueError(f"'{identifier}' is not a valid locale identifier")
+
+    script = territory = variant = None
+    if parts:
+        if len(parts[0]) == 4 and parts[0].isalpha():
+            script = parts.pop(0).title()
+
+    if parts:
+        if len(parts[0]) == 2 and parts[0].isalpha() or len(parts[0]) == 3 and parts[0].isdigit():
+            territory = parts.pop(0).upper()
+
+    if parts:
+        variant = parts.pop(0).upper()
+
+    if parts:
+        raise ValueError(f"'{identifier}' is not a valid locale identifier")
+
+    return (lang, territory, script, variant) if modifier is None else (lang, territory, script, variant, modifier)


 def get_locale_identifier(tup: (tuple[str] | tuple[str, str | None] | tuple
@@ -1042,4 +1130,14 @@ def get_locale_identifier(tup: (tuple[str] | tuple[str, str | None] | tuple
     :param tup: the tuple as returned by :func:`parse_locale`.
     :param sep: the separator for the identifier.
     """
-    pass
+    parts = [tup[0]]
+    for part in tup[1:]:
+        if part is not None:
+            parts.append(part)
+        elif len(parts) > 1 and parts[-1] is not None:
+            parts.append(None)
+    
+    identifier = sep.join(filter(None, parts[:4]))
+    if len(tup) == 5 and tup[4]:
+        identifier += '@' + tup[4]
+    return identifier
diff --git a/babel/dates.py b/babel/dates.py
index 894d925..0f68e88 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -52,7 +52,20 @@ def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) ->tuple[datetime.datetime |

     :rtype: tuple[datetime, tzinfo]
     """
-    pass
+    if isinstance(dt_or_tzinfo, datetime.datetime):
+        return dt_or_tzinfo, dt_or_tzinfo.tzinfo or UTC
+    elif isinstance(dt_or_tzinfo, datetime.tzinfo):
+        return None, dt_or_tzinfo
+    elif isinstance(dt_or_tzinfo, str):
+        return None, get_timezone(dt_or_tzinfo)
+    elif isinstance(dt_or_tzinfo, int):
+        return datetime.datetime.fromtimestamp(dt_or_tzinfo, UTC), UTC
+    elif isinstance(dt_or_tzinfo, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), dt_or_tzinfo), dt_or_tzinfo.tzinfo or UTC
+    elif dt_or_tzinfo is None:
+        return None, UTC
+    else:
+        raise TypeError(f"Unsupported type for dt_or_tzinfo: {type(dt_or_tzinfo)}")


 def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) ->str:
@@ -61,7 +74,15 @@ def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) ->str:

     :rtype: str
     """
-    pass
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    if tzinfo is None:
+        raise ValueError("Unable to determine timezone")
+    if hasattr(tzinfo, 'zone'):
+        return tzinfo.zone
+    elif hasattr(tzinfo, 'tzname'):
+        return tzinfo.tzname(dt)
+    else:
+        return str(tzinfo)


 def _get_datetime(instant: _Instant) ->datetime.datetime:
@@ -95,7 +116,18 @@ def _get_datetime(instant: _Instant) ->datetime.datetime:
     :return: a datetime
     :rtype: datetime
     """
-    pass
+    if instant is None:
+        return datetime.datetime.now(UTC)
+    elif isinstance(instant, datetime.datetime):
+        return instant
+    elif isinstance(instant, datetime.date):
+        return datetime.datetime(instant.year, instant.month, instant.day)
+    elif isinstance(instant, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), instant)
+    elif isinstance(instant, (int, float)):
+        return datetime.datetime.fromtimestamp(instant, UTC)
+    else:
+        raise TypeError(f"Unsupported type for instant: {type(instant)}")


 def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: (datetime.tzinfo |
@@ -120,7 +152,13 @@ def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: (datetime.tzinfo |
     :return: datetime with tzinfo
     :rtype: datetime
     """
-    pass
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    
+    if tzinfo is not None and tzinfo != dt.tzinfo:
+        dt = dt.astimezone(tzinfo)
+    
+    return dt


 def _get_time(time: (datetime.time | datetime.datetime | None), tzinfo: (
@@ -133,7 +171,22 @@ def _get_time(time: (datetime.time | datetime.datetime | None), tzinfo: (
     :param time: time, datetime or None
     :rtype: time
     """
-    pass
+    if time is None:
+        time = datetime.datetime.now(UTC)
+    
+    if isinstance(time, datetime.datetime):
+        if tzinfo is not None and time.tzinfo != tzinfo:
+            time = time.astimezone(tzinfo)
+        return time.timetz()
+    elif isinstance(time, datetime.time):
+        if tzinfo is not None and time.tzinfo != tzinfo:
+            # Create a datetime to perform timezone conversion
+            dt = datetime.datetime.combine(datetime.date.today(), time)
+            dt = dt.astimezone(tzinfo)
+            return dt.timetz()
+        return time
+    else:
+        raise TypeError(f"Unsupported type for time: {type(time)}")


 def get_timezone(zone: (str | datetime.tzinfo | None)=None) ->datetime.tzinfo:
diff --git a/babel/languages.py b/babel/languages.py
index 11dd1ae..16a2ff6 100644
--- a/babel/languages.py
+++ b/babel/languages.py
@@ -25,7 +25,22 @@ def get_official_languages(territory: str, regional: bool=False, de_facto:
     :return: Tuple of language codes
     :rtype: tuple[str]
     """
-    pass
+    territory_data = get_global('territory_languages').get(territory, {})
+    official_languages = []
+
+    for lang, info in territory_data.items():
+        status = info.get('official_status')
+        if status == 'official':
+            official_languages.append(lang)
+        elif regional and status == 'official_regional':
+            official_languages.append(lang)
+        elif de_facto and status == 'de_facto_official':
+            official_languages.append(lang)
+
+    # Sort languages by population percentage (descending order)
+    official_languages.sort(key=lambda x: territory_data[x].get('population_percent', 0), reverse=True)
+
+    return tuple(official_languages)


 def get_territory_language_info(territory: str) ->dict[str, dict[str, float |
@@ -54,4 +69,15 @@ def get_territory_language_info(territory: str) ->dict[str, dict[str, float |
     :return: Language information dictionary
     :rtype: dict[str, dict]
     """
-    pass
+    territory_data = get_global('territory_languages').get(territory, {})
+    result = {}
+
+    for lang, info in territory_data.items():
+        lang_info = {}
+        if 'population_percent' in info:
+            lang_info['population_percent'] = info['population_percent']
+        if 'official_status' in info:
+            lang_info['official_status'] = info['official_status']
+        result[lang] = lang_info
+
+    return result
diff --git a/babel/lists.py b/babel/lists.py
index cb84e96..ac92a70 100644
--- a/babel/lists.py
+++ b/babel/lists.py
@@ -66,4 +66,29 @@ def format_list(lst: Sequence[str], style: Literal['standard',
     :param style: the style to format the list with. See above for description.
     :param locale: the locale
     """
-    pass
+    if not lst:
+        return ""
+    
+    if len(lst) == 1:
+        return lst[0]
+    
+    locale_obj = Locale.parse(locale) if isinstance(locale, str) else locale or DEFAULT_LOCALE
+    
+    list_patterns = locale_obj.list_patterns
+    pattern = list_patterns.get(style, list_patterns.get('standard'))
+    
+    if not pattern:
+        raise ValueError(f"List pattern style '{style}' not available for locale '{locale_obj}'")
+    
+    start = pattern['start']
+    middle = pattern['middle']
+    end = pattern['end']
+    two = pattern['2']
+    
+    if len(lst) == 2:
+        return two.format(lst[0], lst[1])
+    
+    result = start.format(lst[0], lst[1])
+    for item in lst[2:-1]:
+        result = middle.format(result, item)
+    return end.format(result, lst[-1])
diff --git a/babel/localedata.py b/babel/localedata.py
index c54dad6..421495c 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -34,14 +34,28 @@ def normalize_locale(name: str) ->(str | None):
     Returns the normalized locale ID string or `None` if the ID is not
     recognized.
     """
-    pass
+    name = name.strip().lower()
+    parts = name.split('_')
+    if len(parts) == 1:
+        return parts[0]
+    elif len(parts) == 2:
+        return f"{parts[0]}_{parts[1].upper()}"
+    elif len(parts) == 3:
+        return f"{parts[0]}_{parts[1].upper()}_{parts[2].upper()}"
+    return None


 def resolve_locale_filename(name: (os.PathLike[str] | str)) ->str:
     """
     Resolve a locale identifier to a `.dat` path on disk.
     """
-    pass
+    name = os.fspath(name)
+    if _windows_reserved_name_re.match(name):
+        name = f"_{name}"
+    filename = os.path.join(_dirname, f"{name}.dat")
+    if not os.path.exists(filename):
+        raise IOError(f"No locale data file found for '{name}'")
+    return filename


 def exists(name: str) ->bool:
@@ -51,7 +65,11 @@ def exists(name: str) ->bool:

     :param name: the locale identifier string
     """
-    pass
+    try:
+        filename = resolve_locale_filename(name)
+        return os.path.isfile(filename)
+    except IOError:
+        return False


 @lru_cache(maxsize=None)
@@ -66,7 +84,11 @@ def locale_identifiers() ->list[str]:

     :return: a list of locale identifiers (strings)
     """
-    pass
+    return [
+        os.path.splitext(filename)[0]
+        for filename in os.listdir(_dirname)
+        if filename.endswith('.dat') and not filename.startswith('_')
+    ]


 def load(name: (os.PathLike[str] | str), merge_inherited: bool=True) ->dict[
@@ -95,7 +117,25 @@ def load(name: (os.PathLike[str] | str), merge_inherited: bool=True) ->dict[
     :raise `IOError`: if no locale data file is found for the given locale
                       identifier, or one of the locales it inherits from
     """
-    pass
+    global _cache
+    filename = resolve_locale_filename(name)
+    
+    with _cache_lock:
+        data = _cache.get(name)
+        if data is None:
+            with open(filename, 'rb') as fileobj:
+                data = pickle.load(fileobj)
+            _cache[name] = data
+        
+    if merge_inherited:
+        for alias in chain([data.get('alias', {}).get('target')],
+                           data.get('fallback', [])):
+            if alias:
+                merged = load(alias)
+                merge(merged, data)
+                data = merged
+    
+    return LocaleDataDict(data)


 def merge(dict1: MutableMapping[Any, Any], dict2: Mapping[Any, Any]) ->None:
@@ -110,7 +150,18 @@ def merge(dict1: MutableMapping[Any, Any], dict2: Mapping[Any, Any]) ->None:
     :param dict1: the dictionary to merge into
     :param dict2: the dictionary containing the data that should be merged
     """
-    pass
+    for key, value in dict2.items():
+        if key in dict1:
+            if isinstance(dict1[key], MutableMapping) and isinstance(value, Mapping):
+                merge(dict1[key], value)
+            else:
+                dict1[key] = value
+        else:
+            if isinstance(value, Mapping):
+                dict1[key] = {}
+                merge(dict1[key], value)
+            else:
+                dict1[key] = value


 class Alias:
diff --git a/babel/localtime/_fallback.py b/babel/localtime/_fallback.py
index b8b4fdf..9802a82 100644
--- a/babel/localtime/_fallback.py
+++ b/babel/localtime/_fallback.py
@@ -17,4 +17,25 @@ ZERO = datetime.timedelta(0)


 class _FallbackLocalTimezone(datetime.tzinfo):
-    pass
+    def utcoffset(self, dt):
+        if self._isdst(dt):
+            return DSTOFFSET
+        else:
+            return STDOFFSET
+
+    def dst(self, dt):
+        if self._isdst(dt):
+            return DSTDIFF
+        else:
+            return ZERO
+
+    def tzname(self, dt):
+        return time.tzname[self._isdst(dt)]
+
+    def _isdst(self, dt):
+        tt = (dt.year, dt.month, dt.day,
+              dt.hour, dt.minute, dt.second,
+              dt.weekday(), 0, 0)
+        stamp = time.mktime(tt)
+        tt = time.localtime(stamp)
+        return tt.tm_isdst > 0
diff --git a/babel/localtime/_helpers.py b/babel/localtime/_helpers.py
index 821636c..c6441cc 100644
--- a/babel/localtime/_helpers.py
+++ b/babel/localtime/_helpers.py
@@ -11,4 +11,13 @@ def _get_tzinfo(tzenv: str):
     :param tzenv: timezone in the form of Continent/City
     :return: tzinfo object or None if not found
     """
-    pass
+    if pytz is not None:
+        try:
+            return pytz.timezone(tzenv)
+        except pytz.exceptions.UnknownTimeZoneError:
+            return None
+    else:
+        try:
+            return zoneinfo.ZoneInfo(tzenv)
+        except zoneinfo.ZoneInfoNotFoundError:
+            return None
diff --git a/babel/localtime/_unix.py b/babel/localtime/_unix.py
index dd709a3..c2a62cd 100644
--- a/babel/localtime/_unix.py
+++ b/babel/localtime/_unix.py
@@ -13,4 +13,33 @@ def _get_localzone(_root: str='/') ->datetime.tzinfo:
     beneath the _root directory. This is primarily used by the tests.
     In normal usage you call the function without parameters.
     """
-    pass
+    # Check for the TZ environment variable
+    tzenv = os.environ.get('TZ')
+    if tzenv:
+        return _get_tzinfo(tzenv)
+
+    # Check for /etc/timezone file
+    timezone_file = os.path.join(_root, 'etc/timezone')
+    if os.path.exists(timezone_file):
+        with open(timezone_file, 'r') as f:
+            tzname = f.read().strip()
+        if tzname:
+            return _get_tzinfo_or_raise(tzname)
+
+    # Check for /etc/localtime file
+    localtime_file = os.path.join(_root, 'etc/localtime')
+    if os.path.exists(localtime_file):
+        return _get_tzinfo_from_file(localtime_file)
+
+    # Check for /usr/share/zoneinfo/ symlink
+    zoneinfo_dir = os.path.join(_root, 'usr/share/zoneinfo')
+    if os.path.exists(zoneinfo_dir):
+        for root, dirs, files in os.walk(zoneinfo_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if os.path.samefile(file_path, localtime_file):
+                    tzname = os.path.relpath(file_path, zoneinfo_dir)
+                    return _get_tzinfo_or_raise(tzname)
+
+    # If all else fails, return UTC
+    return _get_tzinfo('UTC')
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index 323c08d..0fcc00c 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -16,4 +16,12 @@ except RuntimeError:

 def valuestodict(key) ->dict[str, Any]:
     """Convert a registry key's values to a dictionary."""
-    pass
+    result = {}
+    size = winreg.QueryInfoKey(key)[1]
+    for i in range(size):
+        try:
+            name, data, type = winreg.EnumValue(key, i)
+            result[name] = data
+        except WindowsError:
+            break
+    return result
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 27256d3..f0557d6 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -357,7 +357,12 @@ class Catalog:
         5

         :type: `int`"""
-        pass
+        if self._num_plurals is None:
+            if self.locale:
+                self._num_plurals = get_plural(self.locale)[0]
+            else:
+                self._num_plurals = 2
+        return self._num_plurals

     @property
     def plural_expr(self) ->str:
@@ -371,7 +376,12 @@ class Catalog:
         '(n != 1)'

         :type: `str`"""
-        pass
+        if self._plural_expr is None:
+            if self.locale:
+                self._plural_expr = get_plural(self.locale)[1]
+            else:
+                self._plural_expr = '(n != 1)'
+        return self._plural_expr

     @property
     def plural_forms(self) ->str:
@@ -505,7 +515,10 @@ class Catalog:
                        PO file, if any
         :param context: the message context
         """
-        pass
+        message = Message(id, string, locations, flags, auto_comments,
+                          user_comments, previous_id, lineno, context)
+        self[id] = message
+        return message

     def check(self) ->Iterable[tuple[Message, list[TranslationError]]]:
         """Run various validation checks on the translations in the catalog.
@@ -516,7 +529,10 @@ class Catalog:

         :rtype: ``generator`` of ``(message, errors)``
         """
-        pass
+        for message in self._messages.values():
+            errors = message.check(catalog=self)
+            if errors:
+                yield message, errors

     def get(self, id: _MessageID, context: (str | None)=None) ->(Message | None
         ):
@@ -525,7 +541,8 @@ class Catalog:
         :param id: the message ID
         :param context: the message context, or ``None`` for no context
         """
-        pass
+        key = self._key_for(id, context)
+        return self._messages.get(key)

     def delete(self, id: _MessageID, context: (str | None)=None) ->None:
         """Delete the message with the specified ID and context.
@@ -533,7 +550,9 @@ class Catalog:
         :param id: the message ID
         :param context: the message context, or ``None`` for no context
         """
-        pass
+        key = self._key_for(id, context)
+        if key in self._messages:
+            del self._messages[key]

     def update(self, template: Catalog, no_fuzzy_matching: bool=False,
         update_header_comment: bool=False, keep_user_comments: bool=True,
@@ -594,7 +613,9 @@ class Catalog:

     def _to_fuzzy_match_key(self, key: (tuple[str, str] | str)) ->str:
         """Converts a message key to a string suitable for fuzzy matching."""
-        pass
+        if isinstance(key, tuple):
+            return key[0]
+        return key

     def _key_for(self, id: _MessageID, context: (str | None)=None) ->(tuple
         [str, str] | str):
@@ -602,10 +623,25 @@ class Catalog:
         messages, but is a ``(msgid, msgctxt)`` tuple for context-specific
         messages.
         """
-        pass
+        if isinstance(id, (list, tuple)):
+            id = id[0]
+        if context is not None:
+            return (id, context)
+        return id

     def is_identical(self, other: Catalog) ->bool:
         """Checks if catalogs are identical, taking into account messages and
         headers.
         """
-        pass
+        if len(self) != len(other):
+            return False
+        
+        for key, message in self._messages.items():
+            if key not in other._messages:
+                return False
+            if not message.is_identical(other._messages[key]):
+                return False
+        
+        return (self.mime_headers == other.mime_headers and
+                self.header_comment == other.header_comment and
+                self.fuzzy == other.fuzzy)
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 0161061..1ad1ac4 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -18,12 +18,36 @@ _string_format_compatibilities = [{'i', 'd', 'u'}, {'x', 'X'}, {'f', 'F',

 def num_plurals(catalog: (Catalog | None), message: Message) ->None:
     """Verify the number of plurals in the translation."""
-    pass
+    if not message.pluralizable:
+        return
+    
+    if catalog and catalog.num_plurals:
+        expected = catalog.num_plurals
+    elif message.pluralizable:
+        expected = len(message.id)
+    else:
+        return
+
+    found = len(message.string)
+    if found != expected:
+        raise TranslationError(f"Expected {expected} plurals, found {found}")


 def python_format(catalog: (Catalog | None), message: Message) ->None:
     """Verify the format string placeholders in the translation."""
-    pass
+    if PYTHON_FORMAT not in message.flags:
+        return
+
+    if isinstance(message.id, (list, tuple)):
+        ids = message.id
+    else:
+        ids = [message.id]
+
+    strings = message.string if isinstance(message.string, (list, tuple)) else [message.string]
+
+    for msgid, msgstr in zip(ids, strings):
+        if msgid and msgstr:
+            _validate_format(msgid, msgstr)


 def _validate_format(format: str, alternative: str) ->None:
@@ -57,7 +81,31 @@ def _validate_format(format: str, alternative: str) ->None:
                         against format
     :raises TranslationError: on formatting errors
     """
-    pass
+    import re
+
+    def parse_format(s):
+        return [(m.group(1) or m.group(2), m.group(3))
+                for m in re.finditer(r'%(?:(\([^)]+\))?([#0 +-]?\d*(?:\.\d+)?[hlL]?[diouxXeEfFgGcrs%])|(.)', s)]
+
+    def are_compatible(a, b):
+        if a == b:
+            return True
+        for compat in _string_format_compatibilities:
+            if a in compat and b in compat:
+                return True
+        return False
+
+    format_specs = parse_format(format)
+    alternative_specs = parse_format(alternative)
+
+    if len(format_specs) != len(alternative_specs):
+        raise TranslationError("Different number of placeholders")
+
+    for (f_name, f_type), (a_name, a_type) in zip(format_specs, alternative_specs):
+        if not are_compatible(f_type, a_type):
+            raise TranslationError(f"Incompatible format types: {f_type} and {a_type}")
+        if f_name != a_name:
+            raise TranslationError(f"Mismatched placeholder names: {f_name} and {a_name}")


 checkers: list[Callable[[Catalog | None, Message], object]] = _find_checkers()
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 8af8da4..b4a3b12 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -72,7 +72,11 @@ def _strip_comment_tags(comments: MutableSequence[str], tags: Iterable[str]):
     """Helper function for `extract` that strips comment tags from strings
     in a list of comment lines.  This functions operates in-place.
     """
-    pass
+    for i, comment in enumerate(comments):
+        for tag in tags:
+            if comment.startswith(tag):
+                comments[i] = comment[len(tag):].strip()
+                break


 def extract_from_dir(dirname: (str | os.PathLike[str] | None)=None,
@@ -151,7 +155,23 @@ def extract_from_dir(dirname: (str | os.PathLike[str] | None)=None,
                              should return True if the directory is valid.
     :see: `pathmatch`
     """
-    pass
+    if dirname is None:
+        dirname = os.getcwd()
+    
+    if options_map is None:
+        options_map = {}
+
+    for root, dirs, files in os.walk(str(dirname)):
+        if directory_filter and not directory_filter(root):
+            dirs[:] = []
+            continue
+
+        for filename in files:
+            filepath = os.path.join(root, filename)
+            yield from check_and_call_extract_file(
+                filepath, method_map, options_map, callback,
+                keywords, comment_tags, strip_comment_tags, dirname
+            )


 def check_and_call_extract_file(filepath: (str | os.PathLike[str]),
@@ -189,7 +209,26 @@ def check_and_call_extract_file(filepath: (str | os.PathLike[str]),
     :return: iterable of 5-tuples (filename, lineno, messages, comments, context)
     :rtype: Iterable[tuple[str, int, str|tuple[str], list[str], str|None]
     """
-    pass
+    if dirpath is None:
+        dirpath = os.getcwd()
+    
+    rel_filepath = os.path.relpath(filepath, dirpath)
+
+    for pattern, method in method_map:
+        if pathmatch(pattern, rel_filepath):
+            options = {}
+            for opattern, odict in options_map.items():
+                if pathmatch(opattern, rel_filepath):
+                    options.update(odict)
+            
+            if callback:
+                callback(rel_filepath, method, options)
+            
+            with open(filepath, 'rb') as fileobj:
+                for lineno, message, comments, context in extract_from_file(method, fileobj, keywords, comment_tags, options, strip_comment_tags):
+                    yield (rel_filepath, lineno, message, comments, context)
+            
+            break


 def extract_from_file(method: _ExtractionMethod, filename: (str | os.
@@ -214,7 +253,8 @@ def extract_from_file(method: _ExtractionMethod, filename: (str | os.
     :returns: list of tuples of the form ``(lineno, message, comments, context)``
     :rtype: list[tuple[int, str|tuple[str], list[str], str|None]
     """
-    pass
+    with open(filename, 'rb') as fileobj:
+        return list(extract(method, fileobj, keywords, comment_tags, options, strip_comment_tags))


 def extract(method: _ExtractionMethod, fileobj: _FileObj, keywords: Mapping
@@ -260,7 +300,36 @@ def extract(method: _ExtractionMethod, fileobj: _FileObj, keywords: Mapping
     :returns: iterable of tuples of the form ``(lineno, message, comments, context)``
     :rtype: Iterable[tuple[int, str|tuple[str], list[str], str|None]
     """
-    pass
+    if callable(method):
+        func = method
+    elif ':' in method or '.' in method:
+        if ':' not in method:
+            lastdot = method.rfind('.')
+            module, attrname = method[:lastdot], method[lastdot + 1:]
+        else:
+            module, attrname = method.split(':', 1)
+        func = getattr(__import__(module, {}, {}, [attrname]), attrname)
+    else:
+        try:
+            from pkg_resources import working_set
+        except ImportError:
+            pass
+        else:
+            for entry_point in working_set.iter_entry_points(GROUP_NAME, method):
+                func = entry_point.load(require=True)
+                break
+            else:
+                raise ValueError(f'Unknown extraction method "{method}"')
+
+    results = func(fileobj, keywords.keys(), comment_tags,
+                   options or {})
+    for lineno, funcname, messages, comments in results:
+        if isinstance(messages, str):
+            messages = [messages]
+        if filter(None, messages):
+            if strip_comment_tags:
+                _strip_comment_tags(comments, comment_tags)
+            yield lineno, messages, comments, None


 def extract_nothing(fileobj: _FileObj, keywords: Mapping[str, _Keyword],
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index 8d98f9d..cb26cd4 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -70,7 +70,16 @@ def listify_value(arg, split=None):
     :param split: The argument to pass to `str.split()`.
     :return:
     """
-    pass
+    if isinstance(arg, str):
+        return [s.strip() for s in (arg.split(split) if split else arg.split()) if s.strip()]
+    
+    result = []
+    for item in arg:
+        if isinstance(item, list):
+            result.extend(listify_value(item, split))
+        elif item is not None:
+            result.extend(listify_value(str(item), split))
+    return result


 class CommandMixin:
@@ -109,7 +118,12 @@ def _make_directory_filter(ignore_patterns):
     """
     Build a directory_filter function based on a list of ignore patterns.
     """
-    pass
+    def directory_filter(dirname):
+        for pattern in ignore_patterns:
+            if fnmatch.fnmatch(dirname, pattern):
+                return False
+        return True
+    return directory_filter


 class ExtractMessages(CommandMixin):
@@ -280,7 +294,26 @@ def parse_mapping(fileobj, filename=None):
                     text to parse
     :see: `extract_from_directory`
     """
-    pass
+    config = RawConfigParser()
+    config.read_file(fileobj)
+
+    method_map = []
+    options_map = {}
+
+    extractors = {}
+    if config.has_section('extractors'):
+        extractors = dict(config.items('extractors'))
+
+    for section in config.sections():
+        if section == 'extractors':
+            continue
+        method, pattern = section.split(':', 1)
+        method = extractors.get(method, method)
+        pattern = pattern.strip()
+        method_map.append((pattern, method))
+        options_map[pattern] = dict(config.items(section))
+
+    return method_map, options_map


 def parse_keywords(strings: Iterable[str]=()):
@@ -312,7 +345,38 @@ def parse_keywords(strings: Iterable[str]=()):
     messages. A ``None`` specification is equivalent to ``(1,)``, extracting the first
     argument.
     """
-    pass
+    def parse_spec(spec):
+        if not spec:
+            return None
+        result = []
+        for item in spec.split(','):
+            if item.endswith('c'):
+                result.append((int(item[:-1]), 'c'))
+            else:
+                result.append(int(item))
+        return tuple(result) if result else None
+
+    keywords = {}
+    for string in strings:
+        if ':' in string:
+            funcname, spec = string.split(':')
+        else:
+            funcname, spec = string, None
+
+        if 't' in spec:
+            specs = {}
+            for s in spec.split('t'):
+                if s:
+                    arg_count = int(s[-1])
+                    specs[arg_count] = parse_spec(s[:-1])
+                else:
+                    specs[None] = parse_spec(spec.rstrip('t'))
+        else:
+            specs = parse_spec(spec)
+
+        keywords[funcname] = specs
+
+    return keywords


 def __getattr__(name: str):
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index a00f87d..ed846ec 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -64,21 +64,56 @@ def get_rules(jsx: bool, dotted: bool, template_string: bool) ->list[tuple[

     Internal to this module.
     """
-    pass
+    rules = _rules.copy()
+    if not dotted:
+        rules = [r for r in rules if r[0] != 'dotted_name']
+    if not jsx:
+        rules = [r for r in rules if r[0] != 'jsx_tag']
+    if not template_string:
+        rules = [r for r in rules if r[0] != 'template_string']
+    return rules


 def indicates_division(token: Token) ->bool:
     """A helper function that helps the tokenizer to decide if the current
     token may be followed by a division operator.
     """
-    pass
+    if token.type == 'number' or token.type == 'name':
+        return True
+    if token.type == 'operator':
+        return token.value in [')', ']', '}', '++', '--']
+    return False


 def unquote_string(string: str) ->str:
     """Unquote a string with JavaScript rules.  The string has to start with
     string delimiters (``'``, ``"`` or the back-tick/grave accent (for template strings).)
     """
-    pass
+    quote = string[0]
+    if quote not in ("'", '"', '`'):
+        raise ValueError('string must start with a quote')
+    string = string[1:-1]
+
+    result = []
+    escape = False
+    for char in string:
+        if escape:
+            if char in escapes:
+                result.append(escapes[char])
+            elif char == 'u':
+                result.append(chr(int(string[i+1:i+5], 16)))
+                i += 4
+            elif char == 'x':
+                result.append(chr(int(string[i+1:i+3], 16)))
+                i += 2
+            else:
+                result.append(char)
+            escape = False
+        elif char == '\\':
+            escape = True
+        else:
+            result.append(char)
+    return ''.join(result)


 def tokenize(source: str, jsx: bool=True, dotted: bool=True,
@@ -91,4 +126,33 @@ def tokenize(source: str, jsx: bool=True, dotted: bool=True,
     :param template_string: Support ES6 template strings
     :param lineno: starting line number (optional)
     """
-    pass
+    rules = get_rules(jsx, dotted, template_string)
+    source = source.replace('\r\n', '\n').replace('\r', '\n') + '\n'
+    pos = 0
+    end = len(source)
+    last_token = None
+
+    while pos < end:
+        for token_type, rule in rules:
+            match = rule.match(source, pos)
+            if match is not None:
+                value = match.group()
+                if token_type is not None:
+                    if token_type == 'operator' and value in ('/', '/='):
+                        # Check if this is actually a regex
+                        if last_token is None or not indicates_division(last_token):
+                            regex_match = regex_re.match(source, pos)
+                            if regex_match is not None:
+                                value = regex_match.group()
+                                token_type = 'regex'
+
+                    token = Token(token_type, value, lineno)
+                    yield token
+                    last_token = token
+
+                lineno += len(re.findall(r'\n', value))
+                pos = match.end()
+                break
+        else:
+            # If we get here, no rule matched
+            raise ValueError(f'Invalid syntax at line {lineno}')
diff --git a/babel/messages/mofile.py b/babel/messages/mofile.py
index 2924f4e..44b263f 100644
--- a/babel/messages/mofile.py
+++ b/babel/messages/mofile.py
@@ -28,7 +28,59 @@ def read_mo(fileobj: SupportsRead[bytes]) ->Catalog:
            ``GNUTranslations._parse`` method of the ``gettext`` module in the
            standard library.
     """
-    pass
+    catalog = Catalog()
+    buf = fileobj.read()
+    buflen = len(buf)
+    unpack = struct.unpack
+
+    # Parse the magic number
+    magic = unpack('<I', buf[:4])[0]
+    if magic == LE_MAGIC:
+        version, msgcount, masteridx, transidx = unpack('<4I', buf[4:20])
+        ii = '<II'
+    elif magic == BE_MAGIC:
+        version, msgcount, masteridx, transidx = unpack('>4I', buf[4:20])
+        ii = '>II'
+    else:
+        raise IOError('Invalid magic number')
+
+    # Parse the version number
+    if version != 0:
+        raise IOError('Unknown MO file version')
+
+    # Parse the catalog
+    for i in range(msgcount):
+        mlen, moff = unpack(ii, buf[masteridx:masteridx + 8])
+        mend = moff + mlen
+        tlen, toff = unpack(ii, buf[transidx:transidx + 8])
+        tend = toff + tlen
+        if mend > buflen or tend > buflen:
+            raise IOError('File is corrupt')
+
+        msg = buf[moff:mend].decode()
+        tmsg = buf[toff:tend].decode()
+
+        if mlen == 0:
+            # Metadata
+            for line in tmsg.split('\n'):
+                if ':' in line:
+                    key, value = line.split(':', 1)
+                    catalog.metadata[key.strip()] = value.strip()
+        else:
+            # Regular message
+            if '\x00' in msg:
+                msgid, msgctxt = msg.split('\x04')
+                tmsg = tmsg.split('\x00')
+                catalog.add(msgid, tmsg[0], context=msgctxt)
+                if len(tmsg) > 1:
+                    catalog.add((msgid, msgid + '_plural'), tmsg, context=msgctxt)
+            else:
+                catalog.add(msg, tmsg)
+
+        masteridx += 8
+        transidx += 8
+
+    return catalog


 def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy:
@@ -80,4 +132,49 @@ def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy:
     :param use_fuzzy: whether translations marked as "fuzzy" should be included
                       in the output
     """
-    pass
+    messages = list(catalog)
+    messages.sort()
+
+    ids = strs = b''
+    offsets = []
+
+    for message in messages:
+        if not message.string or (not use_fuzzy and message.fuzzy):
+            continue
+
+        if isinstance(message.id, (list, tuple)):
+            msgid = '\x00'.join([m.encode('utf-8') for m in message.id])
+        else:
+            msgid = message.id.encode('utf-8')
+        if isinstance(message.string, (list, tuple)):
+            msgstr = '\x00'.join([m.encode('utf-8') for m in message.string])
+        else:
+            msgstr = message.string.encode('utf-8')
+
+        offsets.append((len(ids), len(msgid), len(strs), len(msgstr)))
+        ids += msgid + b'\x00'
+        strs += msgstr + b'\x00'
+
+    # The header is 28 bytes long
+    keystart = 28
+    valuestart = keystart + len(ids)
+    koffsets = []
+    voffsets = []
+    for o1, l1, o2, l2 in offsets:
+        koffsets += [o1 + keystart, l1]
+        voffsets += [o2 + valuestart, l2]
+
+    offsets = koffsets + voffsets
+    output = struct.pack('Iiiiiii',
+        LE_MAGIC,                   # magic
+        0,                          # version
+        len(messages),              # number of entries
+        28,                         # start of key index
+        28 + len(offsets) * 4,      # start of value index
+        0, 0                        # size and offset of hash table
+    )
+    output += array.array("i", offsets).tobytes()
+    output += ids
+    output += strs
+
+    fileobj.write(output)
diff --git a/babel/messages/plurals.py b/babel/messages/plurals.py
index 1097d43..94c4b16 100644
--- a/babel/messages/plurals.py
+++ b/babel/messages/plurals.py
@@ -100,4 +100,15 @@ def get_plural(locale: (str | None)=LC_CTYPE) ->_PluralTuple:
     >>> str(tup)
     'nplurals=1; plural=0;'
     """
-    pass
+    if locale is None:
+        locale = LC_CTYPE
+    
+    if isinstance(locale, str):
+        locale = Locale.parse(locale)
+    
+    try:
+        plural = PLURALS[str(locale)]
+    except KeyError:
+        plural = PLURALS.get(locale.language, DEFAULT_PLURAL)
+    
+    return _PluralTuple(plural)
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index bbc0cb7..f888ae2 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -32,7 +32,7 @@ def unescape(string: str) ->str:

     :param string: the string to unescape
     """
-    pass
+    return string.strip('"').replace(r'\\n', '\n').replace(r'\\"', '"').replace(r'\\', '\\')


 def denormalize(string: str) ->str:
@@ -56,7 +56,9 @@ def denormalize(string: str) ->str:

     :param string: the string to denormalize
     """
-    pass
+    lines = string.strip().split('\n')
+    joined = ''.join(line.strip().strip('"') for line in lines)
+    return unescape(joined)


 class PoFileError(Exception):
@@ -129,14 +131,51 @@ class PoFileParser:
         Add a message to the catalog based on the current parser state and
         clear the state ready to process the next message.
         """
-        pass
+        if self.msgid:
+            if self.msgctxt or self.msgid_plural:
+                msgid = (self.msgctxt, self.msgid)
+                if self.msgid_plural:
+                    msgid += (self.msgid_plural,)
+            else:
+                msgid = self.msgid
+            message = Message(msgid,
+                              self.msgstr,
+                              self.locations,
+                              self.flags,
+                              self.auto_comments,
+                              self.user_comments,
+                              self.previous_msgctxt,
+                              self.previous_msgid,
+                              self.previous_msgid_plural,
+                              self.lineno)
+            self.catalog.add(message, self.offset)
+        self._reset_message_state()

     def parse(self, fileobj: IO[AnyStr]) ->None:
         """
         Reads from the file-like object `fileobj` and adds any po file
         units found in it to the `Catalog` supplied to the constructor.
         """
-        pass
+        for line in fileobj:
+            line = line.decode('utf-8') if isinstance(line, bytes) else line
+            self.counter += 1
+            line = line.strip()
+            if not line:
+                if self.in_msgstr:
+                    self._add_message()
+                continue
+
+            if line.startswith('#'):
+                self._process_comment(line)
+            elif line.startswith('"'):
+                self._process_string(line)
+            elif ':' in line:
+                self._process_metadata(line)
+            else:
+                self._process_message(line)
+
+        if self.msgid:
+            self._add_message()


 def read_po(fileobj: IO[AnyStr], locale: (str | Locale | None)=None, domain:
@@ -188,7 +227,10 @@ def read_po(fileobj: IO[AnyStr], locale: (str | Locale | None)=None, domain:
     :param charset: the character set of the catalog.
     :param abort_invalid: abort read if po file is invalid
     """
-    pass
+    catalog = Catalog(locale=locale, domain=domain, charset=charset)
+    parser = PoFileParser(catalog, ignore_obsolete=ignore_obsolete, abort_invalid=abort_invalid)
+    parser.parse(fileobj)
+    return catalog


 WORD_SEP = re.compile(
@@ -207,7 +249,7 @@ def escape(string: str) ->str:

     :param string: the string to escape
     """
-    pass
+    return '"%s"' % string.replace('\\', '\\\\').replace('\t', '\\t').replace('\r', '\\r').replace('\n', '\\n').replace('"', '\\"')


 def normalize(string: str, prefix: str='', width: int=76) ->str:
@@ -234,7 +276,23 @@ def normalize(string: str, prefix: str='', width: int=76) ->str:
     :param width: the maximum line width; use `None`, 0, or a negative number
                   to completely disable line wrapping
     """
-    pass
+    if width and width > 0:
+        lines = []
+        for idx, line in enumerate(string.splitlines(True)):
+            if len(prefix + line) > width:
+                chunks = []
+                for chunk in WORD_SEP.split(line):
+                    if chunks and len(prefix + ''.join(chunks) + chunk) > width:
+                        lines.append(prefix + ''.join(chunks))
+                        chunks = []
+                    chunks.append(chunk)
+                if chunks:
+                    lines.append(prefix + ''.join(chunks))
+            else:
+                lines.append(prefix + line)
+        string = ''.join(lines)
+    
+    return '""' + ''.join('\n"%s"' % line for line in escape(string).splitlines())


 def write_po(fileobj: SupportsWrite[bytes], catalog: Catalog, width: int=76,
@@ -284,7 +342,72 @@ def write_po(fileobj: SupportsWrite[bytes], catalog: Catalog, width: int=76,
                              updating the catalog
     :param include_lineno: include line number in the location comment
     """
-    pass
+    def write(text):
+        if isinstance(text, str):
+            text = text.encode(catalog.charset, 'strict')
+        fileobj.write(text)
+
+    def write_comment(comment, prefix=''):
+        if width and width > 0:
+            wrapper = textwrap.TextWrapper(width=width,
+                                           break_long_words=False)
+            for line in wrapper.wrap(comment):
+                write(f'#{prefix} {line}\n'.encode(catalog.charset))
+        else:
+            write(f'#{prefix} {comment}\n'.encode(catalog.charset))
+
+    def write_entry(message, plural=False):
+        if not no_location:
+            for filename, lineno in message.locations:
+                if include_lineno:
+                    write(f'#: {filename}:{lineno}\n'.encode(catalog.charset))
+                else:
+                    write(f'#: {filename}\n'.encode(catalog.charset))
+        if message.flags:
+            write('#, {}\n'.format(', '.join(message.flags)).encode(catalog.charset))
+        if message.auto_comments:
+            for comment in message.auto_comments:
+                write_comment(comment, '.')
+        if message.user_comments:
+            for comment in message.user_comments:
+                write_comment(comment)
+        if include_previous:
+            write('#| msgid "{}"\n'.format(message.previous_id[0] if isinstance(message.previous_id, tuple) else message.previous_id).encode(catalog.charset))
+        write('msgid {}\n'.format(normalize(message.id, width=width)).encode(catalog.charset))
+        if plural:
+            write('msgid_plural {}\n'.format(normalize(message.id_plural, width=width)).encode(catalog.charset))
+            for idx, string in enumerate(message.string):
+                write('msgstr[{}] {}\n'.format(idx, normalize(string, width=width)).encode(catalog.charset))
+        else:
+            write('msgstr {}\n'.format(normalize(message.string or '', width=width)).encode(catalog.charset))
+        write(b'\n')
+
+    messages = list(catalog)
+    if sort_output:
+        messages.sort()
+    elif sort_by_file:
+        messages.sort(key=lambda m: m.locations)
+
+    if not omit_header:
+        write('msgid ""\n'.encode(catalog.charset))
+        write('msgstr ""\n'.encode(catalog.charset))
+        headers = catalog.header_comment.splitlines()
+        for header in headers:
+            write('{}\n'.format(header).encode(catalog.charset))
+        write(b'\n')
+
+    for message in messages:
+        if (not message.id) or (ignore_obsolete and message.obsolete):
+            continue
+        if isinstance(message.id, (list, tuple)):
+            write_entry(message, plural=True)
+        else:
+            write_entry(message)
+
+    if not ignore_obsolete:
+        for message in messages:
+            if message.obsolete:
+                write_entry(message)


 def _sort_messages(messages: Iterable[Message], sort_by: Literal['message',
@@ -298,4 +421,9 @@ def _sort_messages(messages: Iterable[Message], sort_by: Literal['message',
     :param sort_by: Sort by which criteria? Options are `message` and `location`.
     :return: list[Message]
     """
-    pass
+    if sort_by == 'message':
+        return sorted(messages, key=lambda m: m.id)
+    elif sort_by == 'location':
+        return sorted(messages, key=lambda m: m.locations[0] if m.locations else ('', 0))
+    else:
+        raise ValueError(f"Invalid sort_by value: {sort_by}")
diff --git a/babel/messages/setuptools_frontend.py b/babel/messages/setuptools_frontend.py
index 626c6dd..1c13404 100644
--- a/babel/messages/setuptools_frontend.py
+++ b/babel/messages/setuptools_frontend.py
@@ -20,7 +20,27 @@ def check_message_extractors(dist, name, value):
     :param value: the value of the keyword argument
     :raise `DistutilsSetupError`: if the value is not valid
     """
-    pass
+    if not isinstance(value, dict):
+        raise SetupError('The value of "message_extractors" must be a dictionary')
+
+    for module, specs in value.items():
+        if not isinstance(module, str):
+            raise SetupError('The keys in the "message_extractors" dictionary '
+                             'must be strings')
+        if not isinstance(specs, list):
+            raise SetupError('The values in the "message_extractors" dictionary '
+                             'must be lists')
+        for spec in specs:
+            if not isinstance(spec, tuple) or len(spec) != 3:
+                raise SetupError('Each spec in the "message_extractors" dictionary '
+                                 'must be a 3-tuple')
+            pattern, func, options = spec
+            if not isinstance(pattern, str):
+                raise SetupError('The first element in a spec must be a string')
+            if not callable(func) and not isinstance(func, str):
+                raise SetupError('The second element in a spec must be callable or a string')
+            if not isinstance(options, dict):
+                raise SetupError('The third element in a spec must be a dictionary')


 class compile_catalog(frontend.CompileCatalog, Command):
diff --git a/babel/numbers.py b/babel/numbers.py
index d54ba55..a1237a7 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -49,7 +49,12 @@ def list_currencies(locale: (Locale | str | None)=None) ->set[str]:
                    provided, returns the list of all currencies from all
                    locales.
     """
-    pass
+    if locale is None:
+        return set(get_global('currency_names').keys())
+    
+    locale = Locale.parse(locale)
+    currencies = locale.currencies.keys()
+    return set(currencies)


 def validate_currency(currency: str, locale: (Locale | str | None)=None
@@ -61,7 +66,8 @@ def validate_currency(currency: str, locale: (Locale | str | None)=None

     Raises a `UnknownCurrencyError` exception if the currency is unknown to Babel.
     """
-    pass
+    if currency not in list_currencies(locale):
+        raise UnknownCurrencyError(currency)


 def is_currency(currency: str, locale: (Locale | str | None)=None) ->bool:
@@ -69,7 +75,11 @@ def is_currency(currency: str, locale: (Locale | str | None)=None) ->bool:

     This method always return a Boolean and never raise.
     """
-    pass
+    try:
+        validate_currency(currency, locale)
+        return True
+    except UnknownCurrencyError:
+        return False


 def normalize_currency(currency: str, locale: (Locale | str | None)=None) ->(
@@ -81,7 +91,11 @@ def normalize_currency(currency: str, locale: (Locale | str | None)=None) ->(

     Returns None if the currency is unknown to Babel.
     """
-    pass
+    try:
+        validate_currency(currency, locale)
+        return currency.upper()
+    except UnknownCurrencyError:
+        return None


 def get_currency_name(currency: str, count: (float | decimal.Decimal | None
@@ -98,7 +112,11 @@ def get_currency_name(currency: str, count: (float | decimal.Decimal | None
                   will be pluralized to that number if possible.
     :param locale: the `Locale` object or locale identifier.
     """
-    pass
+    locale = Locale.parse(locale)
+    if count is not None:
+        plural_form = locale.plural_form(count)
+        return locale.currencies.get(currency, {}).get(f'name_other_{plural_form}', currency)
+    return locale.currencies.get(currency, {}).get('name', currency)


 def get_currency_symbol(currency: str, locale: (Locale | str | None)=LC_NUMERIC
@@ -111,7 +129,8 @@ def get_currency_symbol(currency: str, locale: (Locale | str | None)=LC_NUMERIC
     :param currency: the currency code.
     :param locale: the `Locale` object or locale identifier.
     """
-    pass
+    locale = Locale.parse(locale)
+    return locale.currencies.get(currency, {}).get('symbol', currency)


 def get_currency_precision(currency: str) ->int:
@@ -124,7 +143,7 @@ def get_currency_precision(currency: str) ->int:

     :param currency: the currency code.
     """
-    pass
+    return get_global('currency_fractions').get(currency, {}).get('digits', 2)


 def get_currency_unit_pattern(currency: str, count: (float | decimal.
@@ -146,7 +165,11 @@ def get_currency_unit_pattern(currency: str, count: (float | decimal.
                   pattern for that number will be returned.
     :param locale: the `Locale` object or locale identifier.
     """
-    pass
+    locale = Locale.parse(locale)
+    if count is not None:
+        plural_form = locale.plural_form(count)
+        return locale.currency_unit_patterns.get(plural_form, '{0} {1}')
+    return locale.currency_unit_patterns.get('other', '{0} {1}')


 def get_territory_currencies(territory: str, start_date: (datetime.date |
diff --git a/babel/plural.py b/babel/plural.py
index 8675fdf..5165b7d 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -107,7 +107,9 @@ class PluralRule:
         :param rules: the rules as list or dict, or a `PluralRule` object
         :raise RuleError: if the expression is malformed
         """
-        pass
+        if isinstance(rules, PluralRule):
+            return rules
+        return cls(rules)

     @property
     def rules(self) ->Mapping[str, str]:
@@ -117,7 +119,7 @@ class PluralRule:
         >>> rule.rules
         {'one': 'n is 1'}
         """
-        pass
+        return {tag: _Parser(expr).tokens[0][1] for tag, expr in self.abstract}

     @property
     def tags(self) ->frozenset[str]:
@@ -125,7 +127,7 @@ class PluralRule:
         ``'other'`` rules is not part of this set unless there is an explicit
         rule for it.
         """
-        pass
+        return frozenset(tag for tag, _ in self.abstract)

     def __getstate__(self) ->list[tuple[str, Any]]:
         return self.abstract
@@ -155,7 +157,16 @@ def to_javascript(rule: (Mapping[str, str] | Iterable[tuple[str, str]] |
     :param rule: the rules as list or dict, or a `PluralRule` object
     :raise RuleError: if the expression is malformed
     """
-    pass
+    if not isinstance(rule, PluralRule):
+        rule = PluralRule.parse(rule)
+    
+    compiler = _JavaScriptCompiler()
+    parts = []
+    for tag, ast in rule.abstract:
+        expr = compiler.compile(ast)
+        parts.append(f"({expr}) ? '{tag}' : ")
+    parts.append("'other'")
+    return f"(function(n) {{ return {' '.join(parts)}; }})"


 def to_python(rule: (Mapping[str, str] | Iterable[tuple[str, str]] |
@@ -178,7 +189,20 @@ def to_python(rule: (Mapping[str, str] | Iterable[tuple[str, str]] |
     :param rule: the rules as list or dict, or a `PluralRule` object
     :raise RuleError: if the expression is malformed
     """
-    pass
+    if not isinstance(rule, PluralRule):
+        rule = PluralRule.parse(rule)
+    
+    compiler = _PythonCompiler()
+    parts = []
+    for tag, ast in rule.abstract:
+        expr = compiler.compile(ast)
+        parts.append(f"if {expr}: return '{tag}'")
+    parts.append("return 'other'")
+    
+    code = '\n'.join(parts)
+    namespace = {'MOD': cldr_modulo, 'extract_operands': extract_operands}
+    exec(f"def plural(n):\n    {code}", namespace)
+    return namespace['plural']


 def to_gettext(rule: (Mapping[str, str] | Iterable[tuple[str, str]] |
@@ -192,7 +216,18 @@ def to_gettext(rule: (Mapping[str, str] | Iterable[tuple[str, str]] |
     :param rule: the rules as list or dict, or a `PluralRule` object
     :raise RuleError: if the expression is malformed
     """
-    pass
+    if not isinstance(rule, PluralRule):
+        rule = PluralRule.parse(rule)
+    
+    compiler = _GettextCompiler()
+    parts = []
+    for idx, (tag, ast) in enumerate(rule.abstract):
+        expr = compiler.compile(ast)
+        parts.append(f"({expr}) ? {idx} : ")
+    parts.append(str(len(rule.abstract)))
+    
+    plural_expr = ''.join(parts)
+    return f"nplurals={len(rule.abstract) + 1}; plural=({plural_expr});"


 def in_range_list(num: (float | decimal.Decimal), range_list: Iterable[
@@ -213,7 +248,8 @@ def in_range_list(num: (float | decimal.Decimal), range_list: Iterable[
     >>> in_range_list(10, [(1, 4), (6, 8)])
     False
     """
-    pass
+    num = int(num)
+    return any(start <= num <= end for start, end in range_list)


 def within_range_list(num: (float | decimal.Decimal), range_list: Iterable[
@@ -234,7 +270,8 @@ def within_range_list(num: (float | decimal.Decimal), range_list: Iterable[
     >>> within_range_list(10.5, [(1, 4), (20, 30)])
     False
     """
-    pass
+    num = float(num)
+    return any(start <= num <= end for start, end in range_list)


 def cldr_modulo(a: float, b: float) ->float:
diff --git a/babel/support.py b/babel/support.py
index bd493bb..5adbfb0 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -332,19 +332,19 @@ class NullTranslations(gettext.NullTranslations):
         """Like ``gettext()``, but look the message up in the specified
         domain.
         """
-        pass
+        return message

     def ldgettext(self, domain: str, message: str) ->str:
         """Like ``lgettext()``, but look the message up in the specified
         domain.
         """
-        pass
+        return message.encode(locale.getpreferredencoding())

     def udgettext(self, domain: str, message: str) ->str:
         """Like ``ugettext()``, but look the message up in the specified
         domain.
         """
-        pass
+        return message
     dugettext = udgettext

     def dngettext(self, domain: str, singular: str, plural: str, num: int
@@ -352,21 +352,22 @@ class NullTranslations(gettext.NullTranslations):
         """Like ``ngettext()``, but look the message up in the specified
         domain.
         """
-        pass
+        return singular if num == 1 else plural

     def ldngettext(self, domain: str, singular: str, plural: str, num: int
         ) ->str:
         """Like ``lngettext()``, but look the message up in the specified
         domain.
         """
-        pass
+        result = singular if num == 1 else plural
+        return result.encode(locale.getpreferredencoding())

     def udngettext(self, domain: str, singular: str, plural: str, num: int
         ) ->str:
         """Like ``ungettext()`` but look the message up in the specified
         domain.
         """
-        pass
+        return singular if num == 1 else plural
     dungettext = udngettext
     CONTEXT_ENCODING = '%s\x04%s'

@@ -378,14 +379,14 @@ class NullTranslations(gettext.NullTranslations):
         set, the look up is forwarded to the fallback's ``pgettext()``
         method. Otherwise, the `message` id is returned.
         """
-        pass
+        return message

     def lpgettext(self, context: str, message: str) ->(str | bytes | object):
         """Equivalent to ``pgettext()``, but the translation is returned in the
         preferred system encoding, if no other encoding was explicitly set with
         ``bind_textdomain_codeset()``.
         """
-        pass
+        return message.encode(locale.getpreferredencoding())

     def npgettext(self, context: str, singular: str, plural: str, num: int
         ) ->str:
@@ -399,7 +400,7 @@ class NullTranslations(gettext.NullTranslations):
         ``npgettext()`` method.  Otherwise, when ``num`` is 1 ``singular`` is
         returned, and ``plural`` is returned in all other cases.
         """
-        pass
+        return singular if num == 1 else plural

     def lnpgettext(self, context: str, singular: str, plural: str, num: int
         ) ->(str | bytes):
@@ -407,7 +408,8 @@ class NullTranslations(gettext.NullTranslations):
         preferred system encoding, if no other encoding was explicitly set with
         ``bind_textdomain_codeset()``.
         """
-        pass
+        result = singular if num == 1 else plural
+        return result.encode(locale.getpreferredencoding())

     def upgettext(self, context: str, message: str) ->str:
         """Look up the `context` and `message` id in the catalog and return the
@@ -416,7 +418,7 @@ class NullTranslations(gettext.NullTranslations):
         been set, the look up is forwarded to the fallback's ``upgettext()``
         method.  Otherwise, the `message` id is returned.
         """
-        pass
+        return message

     def unpgettext(self, context: str, singular: str, plural: str, num: int
         ) ->str:
@@ -430,20 +432,20 @@ class NullTranslations(gettext.NullTranslations):
         ``unpgettext()`` method.  Otherwise, when `num` is 1 `singular` is
         returned, and `plural` is returned in all other cases.
         """
-        pass
+        return singular if num == 1 else plural

     def dpgettext(self, domain: str, context: str, message: str) ->(str |
         object):
         """Like `pgettext()`, but look the message up in the specified
         `domain`.
         """
-        pass
+        return message

     def udpgettext(self, domain: str, context: str, message: str) ->str:
         """Like `upgettext()`, but look the message up in the specified
         `domain`.
         """
-        pass
+        return message
     dupgettext = udpgettext

     def ldpgettext(self, domain: str, context: str, message: str) ->(str |
@@ -452,21 +454,21 @@ class NullTranslations(gettext.NullTranslations):
         preferred system encoding, if no other encoding was explicitly set with
         ``bind_textdomain_codeset()``.
         """
-        pass
+        return message.encode(locale.getpreferredencoding())

     def dnpgettext(self, domain: str, context: str, singular: str, plural:
         str, num: int) ->str:
         """Like ``npgettext``, but look the message up in the specified
         `domain`.
         """
-        pass
+        return singular if num == 1 else plural

     def udnpgettext(self, domain: str, context: str, singular: str, plural:
         str, num: int) ->str:
         """Like ``unpgettext``, but look the message up in the specified
         `domain`.
         """
-        pass
+        return singular if num == 1 else plural
     dunpgettext = udnpgettext

     def ldnpgettext(self, domain: str, context: str, singular: str, plural:
@@ -475,7 +477,8 @@ class NullTranslations(gettext.NullTranslations):
         the preferred system encoding, if no other encoding was explicitly set
         with ``bind_textdomain_codeset()``.
         """
-        pass
+        result = singular if num == 1 else plural
+        return result.encode(locale.getpreferredencoding())
     ugettext = gettext.NullTranslations.gettext
     ungettext = gettext.NullTranslations.ngettext

@@ -549,4 +552,8 @@ def _locales_to_names(locales: (Iterable[str | Locale] | str | Locale | None)
                     this list can be either `Locale` objects or locale
                     strings)
     """
-    pass
+    if locales is None:
+        return None
+    if isinstance(locales, (Locale, str)):
+        locales = [locales]
+    return [str(locale) for locale in locales]
diff --git a/babel/units.py b/babel/units.py
index d6014db..af01560 100644
--- a/babel/units.py
+++ b/babel/units.py
@@ -36,7 +36,17 @@ def get_unit_name(measurement_unit: str, length: Literal['short', 'long',
     :param locale: the `Locale` object or locale identifier
     :return: The unit display name, or None.
     """
-    pass
+    locale = Locale.parse(locale)
+    unit_data = locale.unit_patterns
+    
+    if measurement_unit not in unit_data:
+        raise UnknownUnitError(f"{measurement_unit}/{length}", locale)
+    
+    unit_info = unit_data[measurement_unit]
+    if length not in unit_info:
+        raise UnknownUnitError(f"{measurement_unit}/{length}", locale)
+    
+    return unit_info[length].get('name')


 def _find_unit_pattern(unit_id: str, locale: (Locale | str | None)=LC_NUMERIC
@@ -57,7 +67,17 @@ def _find_unit_pattern(unit_id: str, locale: (Locale | str | None)=LC_NUMERIC
     :param unit_id: the code of a measurement unit.
     :return: A key to the `unit_patterns` mapping, or None.
     """
-    pass
+    locale = Locale.parse(locale)
+    unit_data = locale.unit_patterns
+    
+    if unit_id in unit_data:
+        return unit_id
+    
+    for pattern in unit_data.keys():
+        if pattern.endswith(f"-{unit_id}"):
+            return pattern
+    
+    return None


 def format_unit(value: (str | float | decimal.Decimal), measurement_unit:
@@ -115,7 +135,28 @@ def format_unit(value: (str | float | decimal.Decimal), measurement_unit:
                              The special value "default" will use the default numbering system of the locale.
     :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
     """
-    pass
+    locale = Locale.parse(locale)
+    
+    unit_pattern = _find_unit_pattern(measurement_unit, locale)
+    if unit_pattern is None:
+        raise UnknownUnitError(measurement_unit, locale)
+    
+    unit_data = locale.unit_patterns.get(unit_pattern, {}).get(length, {})
+    if not unit_data:
+        raise UnknownUnitError(f"{measurement_unit}/{length}", locale)
+    
+    if isinstance(value, str):
+        formatted_value = value
+    else:
+        formatted_value = format_decimal(value, format=format, locale=locale, numbering_system=numbering_system)
+    
+    if int(float(value)) == 1:
+        pattern = unit_data.get('one', unit_data.get('other', '{0} {1}'))
+    else:
+        pattern = unit_data.get('other', '{0} {1}')
+    
+    unit_name = get_unit_name(measurement_unit, length, locale)
+    return pattern.format(formatted_value, unit_name)


 def _find_compound_unit(numerator_unit: str, denominator_unit: str, locale:
@@ -143,7 +184,14 @@ def _find_compound_unit(numerator_unit: str, denominator_unit: str, locale:
     :return: A key to the `unit_patterns` mapping, or None.
     :rtype: str|None
     """
-    pass
+    locale = Locale.parse(locale)
+    unit_patterns = locale.unit_patterns
+    
+    for pattern in unit_patterns.keys():
+        if pattern.endswith(f"-{numerator_unit}-per-{denominator_unit}"):
+            return pattern
+    
+    return None


 def format_compound_unit(numerator_value: (str | float | decimal.Decimal),
@@ -202,4 +250,27 @@ def format_compound_unit(numerator_value: (str | float | decimal.Decimal),
     :return: A formatted compound value.
     :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
     """
-    pass
+    locale = Locale.parse(locale)
+    
+    if isinstance(numerator_value, str):
+        formatted_numerator = numerator_value
+    elif numerator_unit:
+        formatted_numerator = format_unit(numerator_value, numerator_unit, length, format, locale, numbering_system=numbering_system)
+    else:
+        formatted_numerator = format_decimal(numerator_value, format=format, locale=locale, numbering_system=numbering_system)
+    
+    if isinstance(denominator_value, str):
+        formatted_denominator = denominator_value
+    elif denominator_unit:
+        formatted_denominator = format_unit(denominator_value, denominator_unit, length, format, locale, numbering_system=numbering_system)
+    else:
+        formatted_denominator = format_decimal(denominator_value, format=format, locale=locale, numbering_system=numbering_system)
+    
+    compound_pattern = _find_compound_unit(numerator_unit, denominator_unit, locale)
+    if compound_pattern:
+        unit_data = locale.unit_patterns.get(compound_pattern, {}).get(length, {})
+        pattern = unit_data.get('other', '{0}/{1}')
+        return pattern.format(formatted_numerator, formatted_denominator)
+    else:
+        per_pattern = locale.unit_patterns.get('per', {}).get(length, '{0}/{1}')
+        return per_pattern.format(formatted_numerator, formatted_denominator)
diff --git a/babel/util.py b/babel/util.py
index cec00b5..4857dbc 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -34,7 +34,11 @@ def distinct(iterable: Iterable[_T]) ->Generator[_T, None, None]:

     :param iterable: the iterable collection providing the data
     """
-    pass
+    seen = set()
+    for item in iterable:
+        if item not in seen:
+            seen.add(item)
+            yield item


 PYTHON_MAGIC_COMMENT_re = re.compile(
@@ -52,7 +56,20 @@ def parse_encoding(fp: IO[bytes]) ->(str | None):

     (From Jeff Dairiki)
     """
-    pass
+    pos = fp.tell()
+    fp.seek(0)
+    try:
+        line1 = fp.readline()
+        if line1 and line1.startswith(codecs.BOM_UTF8):
+            return 'utf-8'
+        line2 = fp.readline()
+        for line in (line1, line2):
+            match = PYTHON_MAGIC_COMMENT_re.search(line)
+            if match:
+                return match.group(1).decode('ascii')
+    finally:
+        fp.seek(pos)
+    return None


 PYTHON_FUTURE_IMPORT_re = re.compile(
@@ -63,7 +80,21 @@ def parse_future_flags(fp: IO[bytes], encoding: str='latin-1') ->int:
     """Parse the compiler flags by :mod:`__future__` from the given Python
     code.
     """
-    pass
+    import __future__
+    flags = 0
+    pos = fp.tell()
+    fp.seek(0)
+    try:
+        for line in fp:
+            match = PYTHON_FUTURE_IMPORT_re.search(line.decode(encoding))
+            if match:
+                for feature in match.group(1).split(','):
+                    feature = feature.strip()
+                    if hasattr(__future__, feature):
+                        flags |= getattr(__future__, feature).compiler_flag
+    finally:
+        fp.seek(pos)
+    return flags


 def pathmatch(pattern: str, filename: str) ->bool:
@@ -104,7 +135,15 @@ def pathmatch(pattern: str, filename: str) ->bool:
     :param pattern: the glob pattern
     :param filename: the path name of the file to match against
     """
-    pass
+    import fnmatch
+    parts = filename.split(os.path.sep)
+    patterns = pattern.split(os.path.sep)
+    
+    for idx, part in enumerate(patterns):
+        if part == '**':
+            return fnmatch.fnmatch(os.path.sep.join(parts[idx:]), os.path.sep.join(patterns[idx + 1:]))
+    
+    return fnmatch.fnmatch(filename, pattern)


 class TextWrapper(textwrap.TextWrapper):
@@ -124,7 +163,12 @@ def wraptext(text: str, width: int=70, initial_indent: str='',
     :param subsequent_indent: string that will be prepended to all lines save
                               the first of wrapped output
     """
-    pass
+    wrapper = TextWrapper(width=width,
+                          initial_indent=initial_indent,
+                          subsequent_indent=subsequent_indent,
+                          break_long_words=False,
+                          break_on_hyphens=False)
+    return wrapper.wrap(text)


 odict = collections.OrderedDict