






"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
			from transformers import (
			    AutoConfig,
			    BertConfig,
			    GPTaConfig,
			    TaConfig,
			    TFAutoModel,
			    TFAutoModelForCausalLM,
			    TFAutoModelForMaskedLM,
			    TFAutoModelForPreTraining,
			    TFAutoModelForQuestionAnswering,
			    TFAutoModelForSeqaSeqLM,
			    TFAutoModelForSequenceClassification,
			    TFAutoModelWithLMHead,
			    TFBertForMaskedLM,
			    TFBertForPreTraining,
			    TFBertForQuestionAnswering,
			    TFBertForSequenceClassification,
			    TFBertModel,
			    TFGPTaLMHeadModel,
			    TFRobertaForMaskedLM,
			    TFTaForConditionalGeneration,
			)
			from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
			from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
			from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
			from transformers import (
			    AutoModel,
			    AutoModelForCausalLM,
			    AutoModelForMaskedLM,
			    AutoModelForPreTraining,
			    AutoModelForQuestionAnswering,
			    AutoModelForSeqaSeqLM,
			    AutoModelForSequenceClassification,
			    AutoModelWithLMHead,
			    BertForMaskedLM,
			    BertForPreTraining,
			    BertForQuestionAnswering,
			    BertForSequenceClassification,
			    BertModel,
			    GPTaLMHeadModel,
			    RobertaForMaskedLM,
			    TaForConditionalGeneration,
			)







@is_pt_tf_cross_test
class     UpperCamelCase_ (unittest.TestCase  ):





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Tuple		)		->    Dict:
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
							UpperCAmelCase_  :				List[Any]      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Union[str, Any]      =      TFAutoModel.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Any      =      AutoModel.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    Dict:
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
							UpperCAmelCase_  :				Optional[Any]      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				str      =      TFAutoModelForPreTraining.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Dict      =      AutoModelForPreTraining.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    List[Any]:
				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase_  :				List[Any]      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Union[str, Any]      =      TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				Union[str, Any]      =      TFAutoModelForCausalLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				int      =      AutoModelForCausalLM.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				Union[str, Any]      =      AutoModelForCausalLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Any		)		->    str:
				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase_  :				Dict      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Tuple      =      TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				List[Any]      =      AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    Union[str, Any]:
				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase_  :				Any      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				int      =      TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				Tuple      =      TFAutoModelForMaskedLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Dict      =      AutoModelForMaskedLM.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				List[str]      =      AutoModelForMaskedLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    Dict:
				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase_  :				int      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Dict      =      TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				List[Any]      =      TFAutoModelForSeqaSeqLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Union[str, Any]      =      AutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							UpperCAmelCase_  ,			UpperCAmelCase_  :				Any      =      AutoModelForSeqaSeqLM.from_pretrained(
							    lowerCAmelCase_			,			output_loading_info=lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				List[str]		)		->    str:
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
							UpperCAmelCase_  :				List[Any]      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Tuple      =      TFAutoModelForSequenceClassification.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				List[Any]      =      AutoModelForSequenceClassification.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	@slow
	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[Any]		)		->    Optional[Any]:
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
							UpperCAmelCase_  :				int      =      AutoConfig.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Dict      =      TFAutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)

							UpperCAmelCase_  :				Union[str, Any]      =      AutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Any		)		->    int:
				UpperCAmelCase_  :				Any      =      TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
				self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)
				self.assertEqual(model.num_parameters()			,			14_410		)
				self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_		)			,			14_410		)

				UpperCAmelCase_  :				Any      =      AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
				self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)
				self.assertEqual(model.num_parameters()			,			14_410		)
				self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_		)			,			14_410		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Dict		)		->    List[Any]:
				UpperCAmelCase_  :				Tuple      =      TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_pt=lowerCAmelCase_		)
				self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)
				self.assertEqual(model.num_parameters()			,			14_410		)
				self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_		)			,			14_410		)

				UpperCAmelCase_  :				Dict      =      AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,			from_tf=lowerCAmelCase_		)
				self.assertIsInstance(lowerCAmelCase_			,			lowerCAmelCase_		)
				self.assertEqual(model.num_parameters()			,			14_410		)
				self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_		)			,			14_410		)











"""simple docstring"""
import os

import pytest

from datasets import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
)


lowerCamelCase_       			=   pytest.mark.integration

@pytest.mark.parametrize("path"			,["paws", "csv"]		)
def        snake_case   (     A__			,A__		):
			inspect_dataset(A__			,A__		)
			UpperCAmelCase_  :				Tuple      =      path + ".py"
			assert script_name in os.listdir(A__		)
			assert "__pycache__" not in os.listdir(A__		)

@pytest.mark.filterwarnings("ignore:inspect_metric is deprecated:FutureWarning"		)
@pytest.mark.filterwarnings("ignore:metric_module_factory is deprecated:FutureWarning"		)
@pytest.mark.parametrize("path"			,["accuracy"]		)
def        snake_case   (     A__			,A__		):
			inspect_metric(A__			,A__		)
			UpperCAmelCase_  :				List[str]      =      path + ".py"
			assert script_name in os.listdir(A__		)
			assert "__pycache__" not in os.listdir(A__		)

@pytest.mark.parametrize(
    "path, config_name, expected_splits"			,[
        ("squad", "plain_text", ["train", "validation"]),
        ("dalle-mini/wit", "dalle-mini--wit", ["train"]),
        ("paws", "labeled_final", ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				Dict      =      get_dataset_config_info(A__			,config_name=A__		)
			assert info.config_name == config_name
			assert list(info.splits.keys()		) == expected_splits

@pytest.mark.parametrize(
    "path, config_name, expected_exception"			,[
        ("paws", None, ValueError),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			with pytest.raises(A__		):
						get_dataset_config_info(A__			,config_name=A__		)

@pytest.mark.parametrize(
    "path, expected"			,[
        ("squad", "plain_text"),
        ("acronym_identification", "default"),
        ("lhoestq/squad", "plain_text"),
        ("lhoestq/test", "default"),
        ("lhoestq/demo1", "lhoestq--demo1"),
        ("dalle-mini/wit", "dalle-mini--wit"),
    ]			,)
def        snake_case   (     A__			,A__		):
			UpperCAmelCase_  :				str      =      get_dataset_config_names(A__		)
			assert expected in config_names

@pytest.mark.parametrize(
    "path, expected_configs, expected_splits_in_first_config"			,[
        ("squad", ["plain_text"], ["train", "validation"]),
        ("dalle-mini/wit", ["dalle-mini--wit"], ["train"]),
        ("paws", ["labeled_final", "labeled_swap", "unlabeled_final"], ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				List[str]      =      get_dataset_infos(A__		)
			assert list(infos.keys()		) == expected_configs
			UpperCAmelCase_  :				List[str]      =      expected_configs[0]
			assert expected_config in infos
			UpperCAmelCase_  :				int      =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()		) == expected_splits_in_first_config

@pytest.mark.parametrize(
    "path, expected_config, expected_splits"			,[
        ("squad", "plain_text", ["train", "validation"]),
        ("dalle-mini/wit", "dalle-mini--wit", ["train"]),
        ("paws", "labeled_final", ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				Optional[Any]      =      get_dataset_infos(A__		)
			assert expected_config in infos
			UpperCAmelCase_  :				Union[str, Any]      =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()		) == expected_splits




@pytest.mark.parametrize(
    "path, config_name, expected_exception"			,[
        ("paws", None, ValueError),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			with pytest.raises(A__		):
						get_dataset_split_names(A__			,config_name=A__		)



