# Path: natsort/utils.py
# class NumericalRegularExpressions:
#     def _construct_regex(cls, fmt: str) -> Pattern[str]:
#     def int_sign(cls) -> Pattern[str]:
#     def int_nosign(cls) -> Pattern[str]:
#     def float_sign_exp(cls) -> Pattern[str]:
#     def float_nosign_exp(cls) -> Pattern[str]:
#     def float_sign_noexp(cls) -> Pattern[str]:
#     def float_nosign_noexp(cls) -> Pattern[str]:
# def regex_chooser(alg: NSType) -> Pattern[str]:
# def _no_op(x: Any) -> Any:
# def _normalize_input_factory(alg: NSType) -> StrToStr:
# def _compose_input_factory(alg: NSType) -> StrToStr:
# def natsort_key(
#     val: NatsortInType,
#     key: None,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def natsort_key(
#     val: Any,
#     key: KeyType,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def natsort_key(
#     val: Union[NatsortInType, Any],
#     key: MaybeKeyType,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def parse_bytes_factory(alg: NSType) -> BytesTransformer:
# def parse_number_or_none_factory(
#     alg: NSType, sep: StrOrBytes, pre_sep: str
# ) -> MaybeNumTransformer:
#     def func(
#         val: MaybeNumType, _nan_replace: float = nan_replace, _sep: StrOrBytes = sep
#     ) -> NumTuple:
# def parse_string_factory(
#     alg: NSType,
#     sep: StrOrBytes,
#     splitter: StrSplitter,
#     input_transform: StrToStr,
#     component_transform: StrTransformer,
#     final_transform: FinalTransformer,
# ) -> StrParser:
#     def func(x: str) -> FinalTransform:
# def parse_path_factory(str_split: StrParser) -> PathSplitter:
# def sep_inserter(iterator: Iterator[Any], sep: StrOrBytes) -> Iterator[Any]:
# def input_string_transform_factory(alg: NSType) -> StrToStr:
# def string_component_transform_factory(alg: NSType) -> StrTransformer:
# def final_data_transform_factory(
#     alg: NSType, sep: StrOrBytes, pre_sep: str
# ) -> FinalTransformer:
#         def func(
#             split_val: Iterable[NatsortInType],
#             val: str,
#             _transform: StrToStr = transform,
#             _sep: StrOrBytes = sep,
#             _pre_sep: str = pre_sep,
#         ) -> FinalTransform:
#         def func(
#             split_val: Iterable[NatsortInType],
#             val: str,
#             _transform: StrToStr = _no_op,
#             _sep: StrOrBytes = sep,
#             _pre_sep: str = pre_sep,
#         ) -> FinalTransform:
# def groupletters(x: str, _low: StrToStr = lower_function) -> str:
# def chain_functions(functions: Iterable[AnyCall]) -> AnyCall:
# def do_decoding(s: bytes, encoding: str) -> str:
# def do_decoding(s: NatsortInType, encoding: str) -> NatsortInType:
# def do_decoding(s: NatsortInType, encoding: str) -> NatsortInType:
# def path_splitter(
#     s: PathArg, _d_match: MatchFn = re.compile(r"\.\d").match
# ) -> Iterator[str]:
# 
# Path: natsort/ns_enum.py
# class ns(enum.IntEnum):  # noqa: N801
#     FLOAT = F = 1 << next(_counter)
#     SIGNED = S = 1 << next(_counter)
#     NOEXP = N = 1 << next(_counter)
#     PATH = P = 1 << next(_counter)
#     LOCALEALPHA = LA = 1 << next(_counter)
#     LOCALENUM = LN = 1 << next(_counter)
#     IGNORECASE = IC = 1 << next(_counter)
#     LOWERCASEFIRST = LF = 1 << next(_counter)
#     GROUPLETTERS = G = 1 << next(_counter)
#     UNGROUPLETTERS = CAPITALFIRST = C = UG = 1 << next(_counter)
#     NANLAST = NL = 1 << next(_counter)
#     COMPATIBILITYNORMALIZE = CN = 1 << next(_counter)
#     NUMAFTER = NA = 1 << next(_counter)
#     DEFAULT = 0
#     INT = I = 0  # noqa: E741
#     UNSIGNED = U = 0
#     REAL = R = FLOAT | SIGNED
#     LOCALE = L = LOCALEALPHA | LOCALENUM
# NS_DUMB = 1 << 31


import os
import pathlib
import string
import pytest
from itertools import chain
from operator import neg as op_neg
from typing import List, Pattern, Tuple, Union
from hypothesis import given
from hypothesis.strategies import integers, lists, sampled_from, text
from natsort import utils
from natsort.ns_enum import NSType, ns
    "alg, value_or_alias",
    [
        # Defaults
        (ns.DEFAULT, 0),
        (ns.INT, 0),
        (ns.UNSIGNED, 0),
        # Aliases
        (ns.INT, ns.I),
        (ns.UNSIGNED, ns.U),
        (ns.FLOAT, ns.F),
        (ns.SIGNED, ns.S),
        (ns.NOEXP, ns.N),
        (ns.PATH, ns.P),
        (ns.LOCALEALPHA, ns.LA),
        (ns.LOCALENUM, ns.LN),
        (ns.LOCALE, ns.L),
        (ns.IGNORECASE, ns.IC),
        (ns.LOWERCASEFIRST, ns.LF),
        (ns.GROUPLETTERS, ns.G),
        (ns.UNGROUPLETTERS, ns.UG),
        (ns.CAPITALFIRST, ns.C),
        (ns.UNGROUPLETTERS, ns.CAPITALFIRST),
        (ns.NANLAST, ns.NL),
        (ns.COMPATIBILITYNORMALIZE, ns.CN),
        (ns.NUMAFTER, ns.NA),
        # Convenience
        (ns.LOCALE, ns.LOCALEALPHA | ns.LOCALENUM),
        (ns.REAL, ns.FLOAT | ns.SIGNED),
    ],
)

# Path: natsort/utils.py
# class NumericalRegularExpressions:
#     def _construct_regex(cls, fmt: str) -> Pattern[str]:
#     def int_sign(cls) -> Pattern[str]:
#     def int_nosign(cls) -> Pattern[str]:
#     def float_sign_exp(cls) -> Pattern[str]:
#     def float_nosign_exp(cls) -> Pattern[str]:
#     def float_sign_noexp(cls) -> Pattern[str]:
#     def float_nosign_noexp(cls) -> Pattern[str]:
# def regex_chooser(alg: NSType) -> Pattern[str]:
# def _no_op(x: Any) -> Any:
# def _normalize_input_factory(alg: NSType) -> StrToStr:
# def _compose_input_factory(alg: NSType) -> StrToStr:
# def natsort_key(
#     val: NatsortInType,
#     key: None,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def natsort_key(
#     val: Any,
#     key: KeyType,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def natsort_key(
#     val: Union[NatsortInType, Any],
#     key: MaybeKeyType,
#     string_func: Union[StrParser, PathSplitter],
#     bytes_func: BytesTransformer,
#     num_func: MaybeNumTransformer,
# ) -> NatsortOutType:
# def parse_bytes_factory(alg: NSType) -> BytesTransformer:
# def parse_number_or_none_factory(
#     alg: NSType, sep: StrOrBytes, pre_sep: str
# ) -> MaybeNumTransformer:
#     def func(
#         val: MaybeNumType, _nan_replace: float = nan_replace, _sep: StrOrBytes = sep
#     ) -> NumTuple:
# def parse_string_factory(
#     alg: NSType,
#     sep: StrOrBytes,
#     splitter: StrSplitter,
#     input_transform: StrToStr,
#     component_transform: StrTransformer,
#     final_transform: FinalTransformer,
# ) -> StrParser:
#     def func(x: str) -> FinalTransform:
# def parse_path_factory(str_split: StrParser) -> PathSplitter:
# def sep_inserter(iterator: Iterator[Any], sep: StrOrBytes) -> Iterator[Any]:
# def input_string_transform_factory(alg: NSType) -> StrToStr:
# def string_component_transform_factory(alg: NSType) -> StrTransformer:
# def final_data_transform_factory(
#     alg: NSType, sep: StrOrBytes, pre_sep: str
# ) -> FinalTransformer:
#         def func(
#             split_val: Iterable[NatsortInType],
#             val: str,
#             _transform: StrToStr = transform,
#             _sep: StrOrBytes = sep,
#             _pre_sep: str = pre_sep,
#         ) -> FinalTransform:
#         def func(
#             split_val: Iterable[NatsortInType],
#             val: str,
#             _transform: StrToStr = _no_op,
#             _sep: StrOrBytes = sep,
#             _pre_sep: str = pre_sep,
#         ) -> FinalTransform:
# def groupletters(x: str, _low: StrToStr = lower_function) -> str:
# def chain_functions(functions: Iterable[AnyCall]) -> AnyCall:
# def do_decoding(s: bytes, encoding: str) -> str:
# def do_decoding(s: NatsortInType, encoding: str) -> NatsortInType:
# def do_decoding(s: NatsortInType, encoding: str) -> NatsortInType:
# def path_splitter(
#     s: PathArg, _d_match: MatchFn = re.compile(r"\.\d").match
# ) -> Iterator[str]:
# 
# Path: natsort/ns_enum.py
# class ns(enum.IntEnum):  # noqa: N801
#     FLOAT = F = 1 << next(_counter)
#     SIGNED = S = 1 << next(_counter)
#     NOEXP = N = 1 << next(_counter)
#     PATH = P = 1 << next(_counter)
#     LOCALEALPHA = LA = 1 << next(_counter)
#     LOCALENUM = LN = 1 << next(_counter)
#     IGNORECASE = IC = 1 << next(_counter)
#     LOWERCASEFIRST = LF = 1 << next(_counter)
#     GROUPLETTERS = G = 1 << next(_counter)
#     UNGROUPLETTERS = CAPITALFIRST = C = UG = 1 << next(_counter)
#     NANLAST = NL = 1 << next(_counter)
#     COMPATIBILITYNORMALIZE = CN = 1 << next(_counter)
#     NUMAFTER = NA = 1 << next(_counter)
#     DEFAULT = 0
#     INT = I = 0  # noqa: E741
#     UNSIGNED = U = 0
#     REAL = R = FLOAT | SIGNED
#     LOCALE = L = LOCALEALPHA | LOCALENUM
# NS_DUMB = 1 << 31


# Path: tests/test_utils.py
import os
import pathlib
import string
import pytest
from itertools import chain
from operator import neg as op_neg
from typing import List, Pattern, Tuple, Union
from hypothesis import given
from hypothesis.strategies import integers, lists, sampled_from, text
from natsort import utils
from natsort.ns_enum import NSType, ns

    "alg, value_or_alias",
    [
        # Defaults
        (ns.DEFAULT, 0),
        (ns.INT, 0),
        (ns.UNSIGNED, 0),
        # Aliases
        (ns.INT, ns.I),
        (ns.UNSIGNED, ns.U),
        (ns.FLOAT, ns.F),
        (ns.SIGNED, ns.S),
        (ns.NOEXP, ns.N),
        (ns.PATH, ns.P),
        (ns.LOCALEALPHA, ns.LA),
        (ns.LOCALENUM, ns.LN),
        (ns.LOCALE, ns.L),
        (ns.IGNORECASE, ns.IC),
        (ns.LOWERCASEFIRST, ns.LF),
        (ns.GROUPLETTERS, ns.G),
        (ns.UNGROUPLETTERS, ns.UG),
        (ns.CAPITALFIRST, ns.C),
        (ns.UNGROUPLETTERS, ns.CAPITALFIRST),
        (ns.NANLAST, ns.NL),
        (ns.COMPATIBILITYNORMALIZE, ns.CN),
        (ns.NUMAFTER, ns.NA),
        # Convenience
        (ns.LOCALE, ns.LOCALEALPHA | ns.LOCALENUM),
        (ns.REAL, ns.FLOAT | ns.SIGNED),
    ],
)

def test_ns_enum_values_and_aliases(alg: NSType, value_or_alias: NSType) -> None: