



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	:   str				=	field(default="""text-classification"""       ,    metadata={"""include_in_asdict_even_if_is_default""": True}     )
	lowerCAmelCase	:   ClassVar[Features]				=	Features({"""text""": Value("""string"""     )}     )
	lowerCAmelCase	:   ClassVar[Features]				=	Features({"""labels""": ClassLabel}     )
	lowerCAmelCase	:   str				=	"text"
	lowerCAmelCase	:   str				=	"labels"



	def 			__A							(       self			,	UpperCAmelCase__		):
							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]			,	UpperCAmelCase__		):
													raise ValueError(F"""Column {self.label_column} is not a ClassLabel."""		)
							A__							=       copy.deepcopy(self		)
							A__							=       self.label_schema.copy()
							A__							=       features[self.label_column]
							A__							=       label_schema
							return task_template



	@property
	def 			__A							(       self		):
							return {
							    self.text_column: "text",
							    self.label_column: "labels",
							}










from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

UpperCAmelCase_							:      List[Any]      =  [
    "python",
    "tqdm",
    "regex",
    "requests",
    "packaging",
    "filelock",
    "numpy",
    "tokenizers",
    "huggingface-hub",
    "safetensors",
    "accelerate",
    "pyyaml",
]

for pkg in pkgs_to_check_at_runtime:
						if pkg in deps:
												if pkg == "tokenizers":
																		# must be loaded here, or else tqdm check may fail
																		from .utils import is_tokenizers_available

																		if not is_tokenizers_available():
																								continue  # not required, check version only if installed
												elif pkg == "accelerate":
																		# must be loaded here, or else tqdm check may fail
																		from .utils import is_accelerate_available

																		# Maybe switch to is_torch_available in the future here so that Accelerate is hard dep of
																		# Transformers with PyTorch
																		if not is_accelerate_available():
																								continue  # not required, check version only if installed

												require_version_core(deps[pkg])
						else:
												raise ValueError(F'''can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py''')
def  UpperCamelCase						(       _A			:				List[Any]			,							_A			:				int=None    )->       Optional[int]:





						"""simple docstring"""





						require_version(deps[pkg]			,							_A    )





