


'''simple docstring'''






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


a_					:    Optional[Any]          =    logging.get_logger(__name__)

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






def 	_A				(lowerCAmelCase__  :type				,						lowerCAmelCase__  :Optional[str]				,						lowerCAmelCase__  :Optional[List[str]] = None				,						)   ->  Any:




     '''simple docstring'''



     _a			      =							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__})'		)
     _a			      =							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})'		)
          _a			      =							format_type






def 	_A				(lowerCAmelCase__  :Exception				,						lowerCAmelCase__  :Optional[str]				,						lowerCAmelCase__  :Optional[List[str]] = None		)   ->  Union[str, Any]:




     '''simple docstring'''



     _a			      =							aliases if aliases is not None else []
     for alias in set(aliases + [format_type]		):
          _a			      =							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:
       a_					:    Dict          =    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:
       a_					:    Union[str, Any]          =    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:
       a_					:    Any          =    ValueError("JAX needs to be installed to be able to return JAX arrays.")
       _register_unavailable_formatter(_jax_error, "jax", aliases=[])






def 	_A				(lowerCAmelCase__  :Optional[str]		)   ->  Optional[str]:




     '''simple docstring'''



     if format_type in _FORMAT_TYPES_ALIASES:
          return _FORMAT_TYPES_ALIASES[format_type]
     else:
          return format_type






def 	_A				(lowerCAmelCase__  :Optional[str]				,						**lowerCAmelCase__  :int		)   ->  Formatter:




     '''simple docstring'''



     _a			      =							get_format_type_from_alias(lowerCAmelCase__		)
     if format_type in _FORMAT_TYPES:
          return _FORMAT_TYPES[format_type](**lowerCAmelCase__		)
     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}\''		)





'''simple docstring'''






from typing import Any






def 	_A				(lowerCAmelCase__  :list		)   ->  list[Any]:




     '''simple docstring'''



     if not input_list:
          return []
     _a			      =							[input_list.count(lowerCAmelCase__		) for value in input_list]
     _a			      =							max(lowerCAmelCase__		)  # Gets the maximum count in the input list.
     # Gets values of modes
     return sorted({input_list[i] for i, value in enumerate(lowerCAmelCase__		) if value == y}		)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

