


'''simple docstring'''






# 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


__A   :    str											= logging.get_logger(__name__)

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







def 							UpperCamelCase_     (       A__   :  type				,       A__   :  Optional[str]				,       A__   :  Optional[List[str]] = None				,       ):
  '''simple docstring'''





  lowerCAmelCase_     : 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_     : Any     =  format_type







def 							UpperCamelCase_     (       A__   :  Exception				,       A__   :  Optional[str]				,       A__   :  Optional[List[str]] = None   ):
  '''simple docstring'''





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







def 							UpperCamelCase_     (       A__   :  Optional[str]   ):
  '''simple docstring'''





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







def 							UpperCamelCase_     (       A__   :  Optional[str]				,       **A__   :  str   ):
  '''simple docstring'''





  lowerCAmelCase_     : List[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}\''   )







'''simple docstring'''






def 							UpperCamelCase_     (       A__   :  bytes   ):
  '''simple docstring'''





  return "".join([hex(A__   )[2:].zfill(2   ).upper() for byte in list(A__   )]   )







def 							UpperCamelCase_     (       A__   :  str   ):
  '''simple docstring'''





  if (len(A__   ) % 2) != 0:
    raise ValueError(
        """Base16 encoded data is invalid:
Data does not have an even number of hex digits."""   )
  # Check the character set - the standard base16 alphabet
  # is uppercase according to RFC3548 section 6
  if not set(A__   ) <= set("""0123456789ABCDEF"""   ):
    raise ValueError(
        """Base16 encoded data is invalid:
Data is not uppercase hex or it contains invalid characters."""   )
  # For every two hexadecimal digits (= a byte), turn it into an integer.
  # Then, string the result together into bytes, and return it.
  return bytes(int(data[i] + data[i + 1]				,       16   ) for i in range(0				,       len(A__   )				,       2   )   )


if __name__ == "__main__":
  import doctest

  doctest.testmod()



