






"""simple docstring"""




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

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






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


 def _lowercase	(     self		:						Union[str, Any]							,						UpperCAmelCase__		:						Dict							)					->       Optional[int]:
   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  :       Optional[int]             =	copy.deepcopy(self							)
   _a  :       Tuple             =	self.label_schema.copy()
   _a  :       Any             =	features[self.label_column]
   _a  :       Tuple             =	label_schema
   return task_template







 @property
 def _lowercase	(     self		:						List[str]							)					->       Dict[str, str]:
   return {
       self.text_column: "text",
       self.label_column: "labels",
   }









"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_snake_case          =   {
    'configuration_perceiver': ['PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PerceiverConfig', 'PerceiverOnnxConfig'],
    'tokenization_perceiver': ['PerceiverTokenizer'],
}

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _snake_case          =   ['PerceiverFeatureExtractor']
 _snake_case          =   ['PerceiverImageProcessor']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _snake_case          =   [
     'PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'PerceiverForImageClassificationConvProcessing',
     'PerceiverForImageClassificationFourier',
     'PerceiverForImageClassificationLearned',
     'PerceiverForMaskedLM',
     'PerceiverForMultimodalAutoencoding',
     'PerceiverForOpticalFlow',
     'PerceiverForSequenceClassification',
     'PerceiverLayer',
     'PerceiverModel',
     'PerceiverPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_perceiver import PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP, PerceiverConfig, PerceiverOnnxConfig
 from .tokenization_perceiver import PerceiverTokenizer

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_perceiver import PerceiverFeatureExtractor
  from .image_processing_perceiver import PerceiverImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_perceiver import (
      PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST,
      PerceiverForImageClassificationConvProcessing,
      PerceiverForImageClassificationFourier,
      PerceiverForImageClassificationLearned,
      PerceiverForMaskedLM,
      PerceiverForMultimodalAutoencoding,
      PerceiverForOpticalFlow,
      PerceiverForSequenceClassification,
      PerceiverLayer,
      PerceiverModel,
      PerceiverPreTrainedModel,
  )

else:
 import sys

 _snake_case          =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

