

'''simple docstring'''
from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset







class 							A__    (       A__  ):





  def 						A  (		self      :	Optional[Any] )	->    str:





       '''simple docstring'''






       return [
           {"col_1": 3, "col_2": "a"},
           {"col_1": 2, "col_2": "b"},
           {"col_1": 1, "col_2": "c"},
           {"col_1": 0, "col_2": "d"},
       ]





  def 						A  (		self      :	Any )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    ={'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
       return Dataset.from_dict(_a )





  def 						A  (		self      :	Union[str, Any] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self._create_example_records()
       _SCREAMING_SNAKE_CASE							    =Dataset.from_list(_a )
       self.assertListEqual(dset.column_names							,					['col_1', 'col_2'] )
       for i, r in enumerate(_a ):
            self.assertDictEqual(_a							,					example_records[i] )





  def 						A  (		self      :	Union[str, Any] )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self._create_example_records()
       _SCREAMING_SNAKE_CASE							    =Dataset.from_list(_a )
       _SCREAMING_SNAKE_CASE							    =Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]} )
       self.assertEqual(dset.info							,					dset_from_dict.info )





  def 						A  (		self      :	Any )	->    List[Any]:  # checks what happens with missing columns





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =[{'col_1': 1}, {'col_2': 'x'}]
       _SCREAMING_SNAKE_CASE							    =Dataset.from_list(_a )
       self.assertDictEqual(dset[0]							,					{'col_1': 1} )
       self.assertDictEqual(dset[1]							,					{'col_1': None} )  # NB: first record is used for columns





  def 						A  (		self      :	str )	->    int:  # checks if the type can be inferred from the second record





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =[{'col_1': []}, {'col_1': [1, 2]}]
       _SCREAMING_SNAKE_CASE							    =Dataset.from_list(_a )
       self.assertEqual(dset.info.features['col_1']							,					Sequence(Value('int64' ) ) )





  def 						A  (		self      :	Optional[Any] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Dataset.from_list([] )
       self.assertEqual(len(_a )							,					0 )
       self.assertListEqual(dset.column_names							,					[] )



from typing import TYPE_CHECKING

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


lowerCamelCase           =					{
    '''configuration_deberta''': ['''DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DebertaConfig''', '''DebertaOnnxConfig'''],
    '''tokenization_deberta''': ['''DebertaTokenizer'''],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					['''DebertaTokenizerFast''']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''DebertaForMaskedLM''',
           '''DebertaForQuestionAnswering''',
           '''DebertaForSequenceClassification''',
           '''DebertaForTokenClassification''',
           '''DebertaModel''',
           '''DebertaPreTrainedModel''',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''TFDebertaForMaskedLM''',
           '''TFDebertaForQuestionAnswering''',
           '''TFDebertaForSequenceClassification''',
           '''TFDebertaForTokenClassification''',
           '''TFDebertaModel''',
           '''TFDebertaPreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_deberta import DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, DebertaConfig, DebertaOnnxConfig
       from .tokenization_deberta import DebertaTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_deberta_fast import DebertaTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_deberta import (
                  DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DebertaForMaskedLM,
                  DebertaForQuestionAnswering,
                  DebertaForSequenceClassification,
                  DebertaForTokenClassification,
                  DebertaModel,
                  DebertaPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_deberta import (
                  TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFDebertaForMaskedLM,
                  TFDebertaForQuestionAnswering,
                  TFDebertaForSequenceClassification,
                  TFDebertaForTokenClassification,
                  TFDebertaModel,
                  TFDebertaPreTrainedModel,
              )


else:
       import sys

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