# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


lowerCAmelCase			:							List[Any]     =logging.get_logger(__name__)

lowerCAmelCase			:							Dict[Optional[str], Type[Formatter]]     ={}
lowerCAmelCase			:							Dict[Optional[str], str]     ={}
lowerCAmelCase			:							Dict[Optional[str], Exception]     ={}







def 						A__  (					__A   , __A   , __A = None   , ):







    '''simple docstring'''
    _lowerCamelCase     :		List[str] 						=						aliases if aliases is not None else []
    if format_type in _FORMAT_TYPES:
        logger.warning(
            F"""Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"""	)
    _lowerCamelCase     :		Any 						=						formatter_cls
    for alias in set(aliases + [format_type]	):
        if alias in _FORMAT_TYPES_ALIASES:
            logger.warning(
                F"""Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"""	)
        _lowerCamelCase     :		Union[str, Any] 						=						format_type







def 						A__  (					__A   , __A   , __A = None	):







    '''simple docstring'''
    _lowerCamelCase     :		int 						=						aliases if aliases is not None else []
    for alias in set(aliases + [format_type]	):
        _lowerCamelCase     :		Optional[Any] 						=						unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["python"])
_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
_register_formatter(CustomFormatter, "custom")

if config.TORCH_AVAILABLE:
    from .torch_formatter import TorchFormatter

    _register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
else:
    lowerCAmelCase			:							Any     =ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
    _register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])

if config.TF_AVAILABLE:
    from .tf_formatter import TFFormatter

    _register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
else:
    lowerCAmelCase			:							Dict     =ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
    _register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])

if config.JAX_AVAILABLE:
    from .jax_formatter import JaxFormatter

    _register_formatter(JaxFormatter, "jax", aliases=[])
else:
    lowerCAmelCase			:							Union[str, Any]     =ValueError("JAX needs to be installed to be able to return JAX arrays.")
    _register_unavailable_formatter(_jax_error, "jax", aliases=[])







def 						A__  (					__A	):







    '''simple docstring'''
    if format_type in _FORMAT_TYPES_ALIASES:
        return _FORMAT_TYPES_ALIASES[format_type]
    else:
        return format_type







def 						A__  (					__A   , **__A	):







    '''simple docstring'''
    _lowerCamelCase     :		Any 						=						get_format_type_from_alias(__A	)
    if format_type in _FORMAT_TYPES:
        return _FORMAT_TYPES[format_type](**__A	)
    if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
        raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
    else:
        raise ValueError(
            F"""Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None	)}, but got '{format_type}'"""	)





import math







def 						A__  (					__A	):







    '''simple docstring'''
    assert isinstance(__A   , __A	) and (
        number >= 0
    ), "'number' must been an int and positive"

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or not number % 2:
        # Negatives, 0, 1 and all even numbers are not primes
        return False

    _lowerCamelCase     :		List[Any] 						=						range(3   , int(math.sqrt(__A	) + 1	)   , 2	)
    return not any(not number % i for i in odd_numbers	)







def 						A__  (					__A   , __A=1   , **__A	):







    '''simple docstring'''
    _lowerCamelCase     :		Dict 						=						factor * value
    _lowerCamelCase     :		str 						=						value

    while not is_prime(__A	):
        value += 1 if not ("desc" in kwargs and kwargs["desc"] is True) else -1

    if value == first_value_val:
        return next_prime(value + 1   , **__A	)
    return value




