





import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    MODEL_FOR_PRETRAINING_MAPPING,
				    ElectraForCausalLM,
				    ElectraForMaskedLM,
				    ElectraForMultipleChoice,
				    ElectraForPreTraining,
				    ElectraForQuestionAnswering,
				    ElectraForSequenceClassification,
				    ElectraForTokenClassification,
				    ElectraModel,
				)
				from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST





class 		A__    :






	def __init__(     self    ,					lowerCamelCase    ,					lowerCamelCase=13    ,					lowerCamelCase=7    ,					lowerCamelCase=True    ,					lowerCamelCase=True    ,					lowerCamelCase=True    ,					lowerCamelCase=True    ,					lowerCamelCase=99    ,					lowerCamelCase=32    ,					lowerCamelCase=5    ,					lowerCamelCase=4    ,					lowerCamelCase=37    ,					lowerCamelCase="gelu"    ,					lowerCamelCase=0.1    ,					lowerCamelCase=0.1    ,					lowerCamelCase=512    ,					lowerCamelCase=16    ,					lowerCamelCase=2    ,					lowerCamelCase=0.0_2    ,					lowerCamelCase=3    ,					lowerCamelCase=4    ,					lowerCamelCase=None    ,					)				->       Any:




						"""simple docstring"""






						__magic_name__ :							Union[str, Any]		       =							parent
						__magic_name__ :							int		       =							batch_size
						__magic_name__ :							List[Any]		       =							seq_length
						__magic_name__ :							Dict		       =							is_training
						__magic_name__ :							Union[str, Any]		       =							use_input_mask
						__magic_name__ :							Any		       =							use_token_type_ids
						__magic_name__ :							str		       =							use_labels
						__magic_name__ :							Optional[int]		       =							vocab_size
						__magic_name__ :							Any		       =							hidden_size
						__magic_name__ :							Union[str, Any]		       =							num_hidden_layers
						__magic_name__ :							Union[str, Any]		       =							num_attention_heads
						__magic_name__ :							str		       =							intermediate_size
						__magic_name__ :							Optional[int]		       =							hidden_act
						__magic_name__ :							Dict		       =							hidden_dropout_prob
						__magic_name__ :							Tuple		       =							attention_probs_dropout_prob
						__magic_name__ :							Union[str, Any]		       =							max_position_embeddings
						__magic_name__ :							List[Any]		       =							type_vocab_size
						__magic_name__ :							Tuple		       =							type_sequence_label_size
						__magic_name__ :							List[Any]		       =							initializer_range
						__magic_name__ :							int		       =							num_labels
						__magic_name__ :							Optional[int]		       =							num_choices
						__magic_name__ :							Any		       =							scope






	def 			lowercase				(     self						)				->       str:




						"""simple docstring"""






						__magic_name__ :							str		       =							ids_tensor([self.batch_size, self.seq_length]    ,					self.vocab_size						)

						__magic_name__ :							List[Any]		       =							None
						if self.use_input_mask:
											__magic_name__ :							Union[str, Any]		       =							random_attention_mask([self.batch_size, self.seq_length]						)

						__magic_name__ :							Optional[Any]		       =							None
						if self.use_token_type_ids:
											__magic_name__ :							List[Any]		       =							ids_tensor([self.batch_size, self.seq_length]    ,					self.type_vocab_size						)

						__magic_name__ :							List[str]		       =							None
						__magic_name__ :							Optional[Any]		       =							None
						__magic_name__ :							Union[str, Any]		       =							None
						if self.use_labels:
											__magic_name__ :							Union[str, Any]		       =							ids_tensor([self.batch_size]    ,					self.type_sequence_label_size						)
											__magic_name__ :							str		       =							ids_tensor([self.batch_size, self.seq_length]    ,					self.num_labels						)
											__magic_name__ :							Union[str, Any]		       =							ids_tensor([self.batch_size]    ,					self.num_choices						)
											__magic_name__ :							List[Any]		       =							ids_tensor([self.batch_size, self.seq_length]    ,					1						)

						__magic_name__ :							Tuple		       =							self.get_config()

						return (
						    config,
						    input_ids,
						    token_type_ids,
						    input_mask,
						    sequence_labels,
						    token_labels,
						    choice_labels,
						    fake_token_labels,
						)






	def 			lowercase				(     self						)				->       Optional[int]:




						"""simple docstring"""






						return ElectraConfig(
						    vocab_size=self.vocab_size    ,					hidden_size=self.hidden_size    ,					num_hidden_layers=self.num_hidden_layers    ,					num_attention_heads=self.num_attention_heads    ,					intermediate_size=self.intermediate_size    ,					hidden_act=self.hidden_act    ,					hidden_dropout_prob=self.hidden_dropout_prob    ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,					max_position_embeddings=self.max_position_embeddings    ,					type_vocab_size=self.type_vocab_size    ,					is_decoder=lowerCamelCase    ,					initializer_range=self.initializer_range    ,					)






	def 			lowercase				(     self						)				->       Any:




						"""simple docstring"""






						(
						    __magic_name__			
						) :							List[str]		       =							self.prepare_config_and_inputs()

						__magic_name__ :							List[str]		       =							True
						__magic_name__ :							Union[str, Any]		       =							floats_tensor([self.batch_size, self.seq_length, self.hidden_size]						)
						__magic_name__ :							Dict		       =							ids_tensor([self.batch_size, self.seq_length]    ,					vocab_size=2						)

						return (
						    config,
						    input_ids,
						    token_type_ids,
						    input_mask,
						    sequence_labels,
						    token_labels,
						    choice_labels,
						    encoder_hidden_states,
						    encoder_attention_mask,
						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Tuple:




						"""simple docstring"""






						__magic_name__ :							List[Any]		       =							ElectraModel(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							Dict		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase						)
						__magic_name__ :							Optional[Any]		       =							model(lowerCamelCase    ,					token_type_ids=lowerCamelCase						)
						__magic_name__ :							Optional[Any]		       =							model(lowerCamelCase						)
						self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, self.seq_length, self.hidden_size)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Optional[int]:




						"""simple docstring"""






						__magic_name__ :							Any		       =							True
						__magic_name__ :							Union[str, Any]		       =							ElectraModel(lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							str		       =							model(
						    lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					encoder_hidden_states=lowerCamelCase    ,					encoder_attention_mask=lowerCamelCase    ,					)
						__magic_name__ :							str		       =							model(
						    lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					encoder_hidden_states=lowerCamelCase    ,					)
						__magic_name__ :							List[Any]		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase						)
						self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, self.seq_length, self.hidden_size)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       List[str]:




						"""simple docstring"""






						__magic_name__ :							Optional[int]		       =							ElectraForMaskedLM(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							str		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase						)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length, self.vocab_size)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Optional[Any]:




						"""simple docstring"""






						__magic_name__ :							Optional[Any]		       =							ElectraForCausalLM(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							List[str]		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase						)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length, self.vocab_size)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Union[str, Any]:




						"""simple docstring"""






						__magic_name__ :							Union[str, Any]		       =							self.num_labels
						__magic_name__ :							Tuple		       =							ElectraForTokenClassification(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							Optional[Any]		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase						)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length, self.num_labels)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Union[str, Any]:




						"""simple docstring"""






						__magic_name__ :							Any		       =							self.num_labels
						__magic_name__ :							Optional[Any]		       =							ElectraForPreTraining(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							Union[str, Any]		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase						)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       List[Any]:




						"""simple docstring"""






						__magic_name__ :							Any		       =							self.num_labels
						__magic_name__ :							Optional[int]		       =							ElectraForSequenceClassification(lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							Optional[Any]		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase						)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_labels)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Optional[Any]:




						"""simple docstring"""






						__magic_name__ :							Optional[Any]		       =							ElectraForQuestionAnswering(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							int		       =							model(
						    lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					start_positions=lowerCamelCase    ,					end_positions=lowerCamelCase    ,					)
						self.parent.assertEqual(result.start_logits.shape    ,					(self.batch_size, self.seq_length)						)
						self.parent.assertEqual(result.end_logits.shape    ,					(self.batch_size, self.seq_length)						)






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase    ,					)				->       Optional[int]:




						"""simple docstring"""






						__magic_name__ :							int		       =							self.num_choices
						__magic_name__ :							Union[str, Any]		       =							ElectraForMultipleChoice(config=lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()
						__magic_name__ :							Optional[int]		       =							input_ids.unsqueeze(1						).expand(-1    ,					self.num_choices    ,					-1						).contiguous()
						__magic_name__ :							int		       =							token_type_ids.unsqueeze(1						).expand(-1    ,					self.num_choices    ,					-1						).contiguous()
						__magic_name__ :							Any		       =							input_mask.unsqueeze(1						).expand(-1    ,					self.num_choices    ,					-1						).contiguous()
						__magic_name__ :							Tuple		       =							model(
						    lowerCamelCase    ,					attention_mask=lowerCamelCase    ,					token_type_ids=lowerCamelCase    ,					labels=lowerCamelCase    ,					)
						self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_choices)						)






	def 			lowercase				(     self						)				->       List[Any]:




						"""simple docstring"""






						__magic_name__ :							Optional[Any]		       =							self.prepare_config_and_inputs()
						(
						    __magic_name__			
						) :							Optional[Any]		       =							config_and_inputs
						__magic_name__ :							Optional[int]		       =							{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
						return config, inputs_dict





@require_torch
class 		A__    (       __SCREAMING_SNAKE_CASE		,					__SCREAMING_SNAKE_CASE		,					unittest.TestCase			):
	lowerCamelCase__		:			Dict       =(
	    (
	        ElectraModel,
	        ElectraForPreTraining,
	        ElectraForMaskedLM,
	        ElectraForCausalLM,
	        ElectraForMultipleChoice,
	        ElectraForTokenClassification,
	        ElectraForSequenceClassification,
	        ElectraForQuestionAnswering,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCamelCase__		:			str       =(
	    {
	        "feature-extraction": ElectraModel,
	        "fill-mask": ElectraForMaskedLM,
	        "question-answering": ElectraForQuestionAnswering,
	        "text-classification": ElectraForSequenceClassification,
	        "text-generation": ElectraForCausalLM,
	        "token-classification": ElectraForTokenClassification,
	        "zero-shot": ElectraForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	lowerCamelCase__		:			str       =True






	def 			lowercase				(     self    ,					lowerCamelCase    ,					lowerCamelCase    ,					lowerCamelCase=False						)				->       Tuple:




						"""simple docstring"""






						__magic_name__ :							str		       =							super()._prepare_for_class(lowerCamelCase    ,					lowerCamelCase    ,					return_labels=lowerCamelCase						)

						if return_labels:
											if model_class in get_values(lowerCamelCase						):
																__magic_name__ :							Optional[int]		       =							torch.zeros(
																    (self.model_tester.batch_size, self.model_tester.seq_length)    ,					dtype=torch.long    ,					device=lowerCamelCase						)
						return inputs_dict






	def 			lowercase				(     self						)				->       Optional[Any]:




						"""simple docstring"""






						__magic_name__ :							List[str]		       =							ElectraModelTester(self						)
						__magic_name__ :							int		       =							ConfigTester(self    ,					config_class=lowerCamelCase    ,					hidden_size=37						)






	def 			lowercase				(     self						)				->       str:




						"""simple docstring"""






						self.config_tester.run_common_tests()






	def 			lowercase				(     self						)				->       List[Any]:




						"""simple docstring"""






						__magic_name__ :							Dict		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_model(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       Tuple:




						"""simple docstring"""






						__magic_name__ :							Optional[int]		       =							self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_electra_model_as_decoder(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       Any:




						"""simple docstring"""






						__magic_name__ :							Tuple		       =							self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
											__magic_name__ :							Tuple		       =							type
											self.model_tester.create_and_check_electra_model(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       int:




						"""simple docstring"""






						__magic_name__ :							List[Any]		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_masked_lm(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       List[Any]:




						"""simple docstring"""






						__magic_name__ :							Dict		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_token_classification(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       Optional[Any]:




						"""simple docstring"""






						__magic_name__ :							Optional[Any]		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_pretraining(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       int:




						"""simple docstring"""






						__magic_name__ :							List[Any]		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_sequence_classification(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       List[str]:




						"""simple docstring"""






						__magic_name__ :							Union[str, Any]		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_question_answering(*lowerCamelCase						)






	def 			lowercase				(     self						)				->       List[str]:




						"""simple docstring"""






						__magic_name__ :							Optional[Any]		       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_multiple_choice(*lowerCamelCase						)






	@slow
	def 			lowercase				(     self						)				->       List[str]:




						"""simple docstring"""






						for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__magic_name__ :							str		       =							ElectraModel.from_pretrained(lowerCamelCase						)
											self.assertIsNotNone(lowerCamelCase						)






	def 			lowercase				(     self						)				->       Tuple:




						"""simple docstring"""






						__magic_name__ :							List[Any]		       =							self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_electra_for_causal_lm(*lowerCamelCase						)





@require_torch
class 		A__    (       unittest.TestCase			):






	@slow
	def 			lowercase				(     self						)				->       Optional[Any]:




						"""simple docstring"""






						__magic_name__ :							str		       =							ElectraModel.from_pretrained('''google/electra-small-discriminator'''						)
						__magic_name__ :							List[Any]		       =							torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]						)
						__magic_name__ :							Optional[int]		       =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]						)
						__magic_name__ :							Any		       =							model(lowerCamelCase    ,					attention_mask=lowerCamelCase						)[0]
						__magic_name__ :							List[str]		       =							torch.Size((1, 11, 256)						)
						self.assertEqual(output.shape    ,					lowerCamelCase						)
						__magic_name__ :							List[Any]		       =							torch.tensor(
						    [[[0.4_4_7_1, 0.6_8_2_1, -0.3_2_6_5], [0.4_6_2_7, 0.5_2_5_5, -0.3_6_6_8], [0.4_5_3_2, 0.3_3_1_3, -0.4_3_4_4]]]						)

						self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,					lowerCamelCase    ,					atol=1e-4						)						)









import importlib
import os
import platform
from pathlib import Path

from packaging import version

from .utils.logging import get_logger


lowercase_		=							get_logger(__name__)

# Datasets
lowercase_		=							'''https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets'''
lowercase_		=							'''https://cdn-datasets.huggingface.co/datasets/datasets'''
lowercase_		=							'''https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}'''

# Metrics
lowercase_		=							'''https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics'''
lowercase_		=							'''https://cdn-datasets.huggingface.co/datasets/metric'''
lowercase_		=							'''https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}'''

# Hub
lowercase_		=							os.environ.get('''HF_ENDPOINT''', '''https://huggingface.co''')
lowercase_		=							HF_ENDPOINT + '''/datasets/{repo_id}/resolve/{revision}/{path}'''
lowercase_		=							'''main'''

lowercase_		=							version.parse(platform.python_version())

if PY_VERSION < version.parse('''3.8'''):
				import importlib_metadata
else:
				import importlib.metadata as importlib_metadata

# General environment variables accepted values for booleans
lowercase_		=							{'''1''', '''ON''', '''YES''', '''TRUE'''}
lowercase_		=							ENV_VARS_TRUE_VALUES.union({'''AUTO'''})


# Imports
lowercase_		=							version.parse(importlib_metadata.version('''dill'''))
lowercase_		=							version.parse(importlib_metadata.version('''pandas'''))
lowercase_		=							version.parse(importlib_metadata.version('''pyarrow'''))

lowercase_		=							os.environ.get('''USE_TF''', '''AUTO''').upper()
lowercase_		=							os.environ.get('''USE_TORCH''', '''AUTO''').upper()
lowercase_		=							os.environ.get('''USE_JAX''', '''AUTO''').upper()

lowercase_		=							'''N/A'''
lowercase_		=							False

if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
				lowercase_		=							importlib.util.find_spec('''torch''') is not None
				if TORCH_AVAILABLE:
								try:
												lowercase_		=							version.parse(importlib_metadata.version('''torch'''))
												logger.info(f"PyTorch version {TORCH_VERSION} available.")
								except importlib_metadata.PackageNotFoundError:
												pass
else:
				logger.info('''Disabling PyTorch because USE_TF is set''')

lowercase_		=							'''N/A'''
lowercase_		=							False

if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
				lowercase_		=							importlib.util.find_spec('''tensorflow''') is not None
				if TF_AVAILABLE:
								# For the metadata, we have to look for both tensorflow and tensorflow-cpu
								for package in [
								    "tensorflow",
								    "tensorflow-cpu",
								    "tensorflow-gpu",
								    "tf-nightly",
								    "tf-nightly-cpu",
								    "tf-nightly-gpu",
								    "intel-tensorflow",
								    "tensorflow-rocm",
								    "tensorflow-macos",
								]:
												try:
																lowercase_		=							version.parse(importlib_metadata.version(package))
												except importlib_metadata.PackageNotFoundError:
																continue
												else:
																break
								else:
												lowercase_		=							False
				if TF_AVAILABLE:
								if TF_VERSION.major < 2:
												logger.info(f"TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.")
												lowercase_		=							False
								else:
												logger.info(f"TensorFlow version {TF_VERSION} available.")
else:
				logger.info('''Disabling Tensorflow because USE_TORCH is set''')


lowercase_		=							'''N/A'''
lowercase_		=							False

if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
				lowercase_		=							importlib.util.find_spec('''jax''') is not None and importlib.util.find_spec('''jaxlib''') is not None
				if JAX_AVAILABLE:
								try:
												lowercase_		=							version.parse(importlib_metadata.version('''jax'''))
												logger.info(f"JAX version {JAX_VERSION} available.")
								except importlib_metadata.PackageNotFoundError:
												pass
else:
				logger.info('''Disabling JAX because USE_JAX is set to False''')


lowercase_		=							os.environ.get('''USE_BEAM''', '''AUTO''').upper()
lowercase_		=							'''N/A'''
lowercase_		=							False
if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
				try:
								lowercase_		=							version.parse(importlib_metadata.version('''apache_beam'''))
								lowercase_		=							True
								logger.info(f"Apache Beam version {BEAM_VERSION} available.")
				except importlib_metadata.PackageNotFoundError:
								pass
else:
				logger.info('''Disabling Apache Beam because USE_BEAM is set to False''')


# Optional tools for data loading
lowercase_		=							importlib.util.find_spec('''sqlalchemy''') is not None

# Optional tools for feature decoding
lowercase_		=							importlib.util.find_spec('''PIL''') is not None
lowercase_		=							importlib.util.find_spec('''soundfile''') is not None and version.parse(
    importlib.import_module('''soundfile''').__libsndfile_version__
) >= version.parse('''1.0.31''')
lowercase_		=							importlib.util.find_spec('''soundfile''') is not None and version.parse(
    importlib.import_module('''soundfile''').__libsndfile_version__
) >= version.parse('''1.1.0''')

# Optional compression tools
lowercase_		=							importlib.util.find_spec('''rarfile''') is not None
lowercase_		=							importlib.util.find_spec('''zstandard''') is not None
lowercase_		=							importlib.util.find_spec('''lz4''') is not None
lowercase_		=							importlib.util.find_spec('''py7zr''') is not None


# Cache location
lowercase_		=							'''~/.cache'''
lowercase_		=							os.getenv('''XDG_CACHE_HOME''', DEFAULT_XDG_CACHE_HOME)
lowercase_		=							os.path.join(XDG_CACHE_HOME, '''huggingface''')
lowercase_		=							os.path.expanduser(os.getenv('''HF_HOME''', DEFAULT_HF_CACHE_HOME))

lowercase_		=							os.path.join(HF_CACHE_HOME, '''datasets''')
lowercase_		=							Path(os.getenv('''HF_DATASETS_CACHE''', DEFAULT_HF_DATASETS_CACHE))

lowercase_		=							os.path.join(HF_CACHE_HOME, '''metrics''')
lowercase_		=							Path(os.getenv('''HF_METRICS_CACHE''', DEFAULT_HF_METRICS_CACHE))

lowercase_		=							os.path.join(HF_CACHE_HOME, '''modules''')
lowercase_		=							Path(os.getenv('''HF_MODULES_CACHE''', DEFAULT_HF_MODULES_CACHE))

lowercase_		=							'''downloads'''
lowercase_		=							os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
lowercase_		=							Path(os.getenv('''HF_DATASETS_DOWNLOADED_DATASETS_PATH''', DEFAULT_DOWNLOADED_DATASETS_PATH))

lowercase_		=							'''extracted'''
lowercase_		=							os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
lowercase_		=							Path(os.getenv('''HF_DATASETS_EXTRACTED_DATASETS_PATH''', DEFAULT_EXTRACTED_DATASETS_PATH))

# Download count for the website
lowercase_		=							(
    os.environ.get('''HF_UPDATE_DOWNLOAD_COUNTS''', '''AUTO''').upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
)

# Batch size constants. For more info, see:
# https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
lowercase_		=							1000

# Size of the preloaded record batch in `Dataset.__iter__`
lowercase_		=							10

# Pickling tables works only for small tables (<4GiB)
# For big tables, we write them on disk instead
lowercase_		=							4 << 30

# Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
lowercase_		=							'''500MB'''

# Parquet configuration
lowercase_		=							100
lowercase_		=							100
lowercase_		=							100

# Offline mode
lowercase_		=							os.environ.get('''HF_DATASETS_OFFLINE''', '''AUTO''').upper() in ENV_VARS_TRUE_VALUES

# In-memory
lowercase_		=							0  # Disabled
lowercase_		=							float(os.environ.get('''HF_DATASETS_IN_MEMORY_MAX_SIZE''', DEFAULT_IN_MEMORY_MAX_SIZE))

# File names
lowercase_		=							'''dataset.arrow'''
lowercase_		=							'''indices.arrow'''
lowercase_		=							'''state.json'''
lowercase_		=							'''dataset_info.json'''
lowercase_		=							'''dataset_infos.json'''
lowercase_		=							'''LICENSE'''
lowercase_		=							'''metric_info.json'''
lowercase_		=							'''dataset_dict.json'''

lowercase_		=							'''datasets_modules'''

lowercase_		=							255

# Streaming
lowercase_		=							20
lowercase_		=							5

# Datasets without script
lowercase_		=							200
lowercase_		=							10
lowercase_		=							200

# Progress bars
lowercase_		=							0.0_5  # 20 progress updates per sec



