



"""simple docstring"""

import unittest

import numpy as np

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
     from transformers.models.bert.modeling_flax_bert import (
         FlaxBertForMaskedLM,
         FlaxBertForMultipleChoice,
         FlaxBertForNextSentencePrediction,
         FlaxBertForPreTraining,
         FlaxBertForQuestionAnswering,
         FlaxBertForSequenceClassification,
         FlaxBertForTokenClassification,
         FlaxBertModel,
     )




class        _UpperCAmelCase       (			unittest.TestCase):

 def __init__(     self		:       str  ,     lowercase_		:       Any  ,     lowercase_		:       Optional[Any]=13  ,     lowercase_		:       int=7  ,     lowercase_		:       Optional[int]=True  ,     lowercase_		:       Union[str, Any]=True  ,     lowercase_		:       Optional[int]=True  ,     lowercase_		:       Optional[int]=True  ,     lowercase_		:       int=99  ,     lowercase_		:       Dict=32  ,     lowercase_		:       List[Any]=5  ,     lowercase_		:       Dict=4  ,     lowercase_		:       Any=37  ,     lowercase_		:       Any="gelu"  ,     lowercase_		:       List[Any]=0.1  ,     lowercase_		:       List[Any]=0.1  ,     lowercase_		:       str=512  ,     lowercase_		:       Dict=16  ,     lowercase_		:       List[str]=2  ,     lowercase_		:       int=0.02  ,     lowercase_		:       Union[str, Any]=4  ,     ):
     snake_case_ :     Any				=	parent
     snake_case_ :     str				=	batch_size
     snake_case_ :     Any				=	seq_length
     snake_case_ :     List[Any]				=	is_training
     snake_case_ :     Tuple				=	use_attention_mask
     snake_case_ :     Optional[int]				=	use_token_type_ids
     snake_case_ :     List[str]				=	use_labels
     snake_case_ :     Any				=	vocab_size
     snake_case_ :     Optional[int]				=	hidden_size
     snake_case_ :     List[str]				=	num_hidden_layers
     snake_case_ :     Optional[int]				=	num_attention_heads
     snake_case_ :     int				=	intermediate_size
     snake_case_ :     Any				=	hidden_act
     snake_case_ :     Dict				=	hidden_dropout_prob
     snake_case_ :     int				=	attention_probs_dropout_prob
     snake_case_ :     Tuple				=	max_position_embeddings
     snake_case_ :     Tuple				=	type_vocab_size
     snake_case_ :     int				=	type_sequence_label_size
     snake_case_ :     str				=	initializer_range
     snake_case_ :     Any				=	num_choices

 def 						_snake_case					(     self		:       Dict				):
     snake_case_ :     Optional[Any]				=	ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)

     snake_case_ :     Any				=	None
     if self.use_attention_mask:
         snake_case_ :     Union[str, Any]				=	random_attention_mask([self.batch_size, self.seq_length]				)

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

     snake_case_ :     Optional[int]				=	BertConfig(
         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=lowercase_  ,     initializer_range=self.initializer_range  ,     )

     return config, input_ids, token_type_ids, attention_mask

 def 						_snake_case					(     self		:       Union[str, Any]				):
     snake_case_ :     int				=	self.prepare_config_and_inputs()
     snake_case_,	snake_case_,	snake_case_,	snake_case_ :     Optional[Any]				=	config_and_inputs
     snake_case_ :     List[Any]				=	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
     return config, inputs_dict






 def 						_snake_case					(     self		:       Dict				):
     snake_case_ :     Optional[Any]				=	self.prepare_config_and_inputs()
     snake_case_,	snake_case_,	snake_case_,	snake_case_ :     Optional[int]				=	config_and_inputs

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

     return (
         config,
         input_ids,
         attention_mask,
         encoder_hidden_states,
         encoder_attention_mask,
     )





@require_flax
class        _UpperCAmelCase       (			lowerCAmelCase__    ,     unittest.TestCase):
 _lowerCAmelCase   :			List[str]							=		True

 _lowerCAmelCase   :			Optional[int]							=		(
     (
         FlaxBertModel,
         FlaxBertForPreTraining,
         FlaxBertForMaskedLM,
         FlaxBertForMultipleChoice,
         FlaxBertForQuestionAnswering,
         FlaxBertForNextSentencePrediction,
         FlaxBertForSequenceClassification,
         FlaxBertForTokenClassification,
         FlaxBertForQuestionAnswering,
     )
     if is_flax_available()
     else ()
 )

 def 						_snake_case					(     self		:       int				):
     snake_case_ :     str				=	FlaxBertModelTester(self				)






 @slow
 def 						_snake_case					(     self		:       List[Any]				):
     # Only check this for base model, not necessary for all model classes.
     # This will also help speed-up tests.
     snake_case_ :     List[Any]				=	FlaxBertModel.from_pretrained('''bert-base-cased'''				)
     snake_case_ :     Any				=	model(np.ones((1, 1)				)				)
     self.assertIsNotNone(lowercase_				)










"""simple docstring"""

from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)





