


'''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


lowerCAmelCase				:Tuple        =      logging.get_logger(__name__)

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





def lowerCamelCase      (      lowerCAmelCase    :     type		,		lowerCAmelCase    :     Optional[str]		,		lowerCAmelCase    :     Optional[List[str]] = None		,		):





 """simple docstring"""







 __magic_name__	:   List[Any]					     =					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__})'		)
 __magic_name__	:   Optional[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})'		)
  __magic_name__	:   Tuple					     =					format_type





def lowerCamelCase      (      lowerCAmelCase    :     Exception		,		lowerCAmelCase    :     Optional[str]		,		lowerCAmelCase    :     Optional[List[str]] = None		):





 """simple docstring"""







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





def lowerCamelCase      (      lowerCAmelCase    :     Optional[str]		):





 """simple docstring"""







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





def lowerCamelCase      (      lowerCAmelCase    :     Optional[str]		,		**lowerCAmelCase    :     Dict		):





 """simple docstring"""







 __magic_name__	:   Tuple					     =					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'''

# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
lowerCAmelCase				:Optional[int]        =      abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)





def lowerCamelCase      (      lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	config.addinivalue_line(
	    'markers'		,		'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'		)
	config.addinivalue_line(
	    'markers'		,		'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'		)
	config.addinivalue_line('markers'		,		'is_pipeline_test: mark test to run only when pipelines are tested'		)
	config.addinivalue_line('markers'		,		'is_staging_test: mark test to run only in the staging environment'		)
	config.addinivalue_line('markers'		,		'accelerate_tests: mark test that require accelerate'		)
	config.addinivalue_line('markers'		,		'tool_tests: mark the tool tests that are run on their specific schedule'		)





def lowerCamelCase      (      lowerCAmelCase    :     Any		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_addoption_shared

	pytest_addoption_shared(lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     Dict		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_terminal_summary_main

	__magic_name__	:   Tuple					     =					terminalreporter.config.getoption('--make-reports'		)
	if make_reports:
		pytest_terminal_summary_main(lowerCAmelCase		,		id=lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     List[Any]		,		lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	if exitstatus == 5:
		__magic_name__	:   Any					     =					0


# Doctest custom flag to ignore output.
lowerCAmelCase				:List[str]        =      doctest.register_optionflag('''IGNORE_RESULT''')

lowerCAmelCase				:Union[str, Any]        =      doctest.OutputChecker
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						Tuple  ,					_A		:						Tuple  ,					_A		:						str      )  ->			int:
			if IGNORE_RESULT & optionflags:
				return True
			return OutputChecker.check_output(self  ,					_A  ,					_A  ,					_A      )







lowerCAmelCase				:Optional[Any]        =      CustomOutputChecker
lowerCAmelCase				:int        =      HfDoctestModule





lowerCAmelCase				:Any        =      HfDocTestParser