



# 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


__snake_case     :Union[str, Any]			       =logging.get_logger(__name__)

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






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

							'''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  lowerCamelCase_	(      lowerCAmelCase__	:	Exception			,	lowerCAmelCase__	:	Optional[str]			,	lowerCAmelCase__	:	Optional[List[str]] = None				)       ->							Optional[int]:

							'''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:
				__snake_case     :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:
				__snake_case     :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:
				__snake_case     :Dict			       =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]				)       ->							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__	:	Any				)       ->							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}\''''				)






import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Value
from .base import TaskTemplate




@dataclass(frozen=UpperCamelCase__     )
class 	UpperCamelCase_							(  UpperCamelCase__     ):
							# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
							lowerCamelCase_							     =       field(default="text-classification"					,	metadata={"include_in_asdict_even_if_is_default": True}     )
							lowerCamelCase_							     =       Features({"text": Value("string"     )}     )
							lowerCamelCase_							     =       Features({"labels": ClassLabel}     )
							lowerCamelCase_							     =       "text"
							lowerCamelCase_							     =       "labels"


							def   _snake_case	(				self     :Any				,					__A     :Dict		) -> Optional[Any]:



									"""simple docstring"""



									if self.label_column not in features:
											raise ValueError(f'''Column {self.label_column} is not present in features.'''		)
									if not isinstance(features[self.label_column]				,					__A		):
											raise ValueError(f'''Column {self.label_column} is not a ClassLabel.'''		)
									SCREAMING_SNAKE_CASE__								=   copy.deepcopy(self		)
									SCREAMING_SNAKE_CASE__								=   self.label_schema.copy()
									SCREAMING_SNAKE_CASE__								=   features[self.label_column]
									SCREAMING_SNAKE_CASE__								=   label_schema
									return task_template


							@property
							def   _snake_case	(				self     :str		) -> Dict[str, str]:



									"""simple docstring"""



									return {
									    self.text_column: "text",
									    self.label_column: "labels",
									}