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   lowercase      (       unittest.TestCase       ):




							def __init__(  self				:   Tuple		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Optional[Any]=13		,							_UpperCamelCase				:   Optional[int]=7		,							_UpperCamelCase				:   Union[str, Any]=True		,							_UpperCamelCase				:   Any=True		,							_UpperCamelCase				:   Tuple=True		,							_UpperCamelCase				:   Optional[Any]=True		,							_UpperCamelCase				:   Tuple=99		,							_UpperCamelCase				:   Optional[Any]=32		,							_UpperCamelCase				:   Union[str, Any]=5		,							_UpperCamelCase				:   List[str]=4		,							_UpperCamelCase				:   str=37		,							_UpperCamelCase				:   str="gelu"		,							_UpperCamelCase				:   str=0.1		,							_UpperCamelCase				:   List[Any]=0.1		,							_UpperCamelCase				:   Optional[int]=512		,							_UpperCamelCase				:   Optional[Any]=16		,							_UpperCamelCase				:   Union[str, Any]=2		,							_UpperCamelCase				:   Optional[Any]=0.0_2		,							_UpperCamelCase				:   int=4		,							)   ->			Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    parent
												SCREAMING_SNAKE_CASE           =    batch_size
												SCREAMING_SNAKE_CASE           =    seq_length
												SCREAMING_SNAKE_CASE           =    is_training
												SCREAMING_SNAKE_CASE           =    use_attention_mask
												SCREAMING_SNAKE_CASE           =    use_token_type_ids
												SCREAMING_SNAKE_CASE           =    use_labels
												SCREAMING_SNAKE_CASE           =    vocab_size
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    hidden_dropout_prob
												SCREAMING_SNAKE_CASE           =    attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE           =    max_position_embeddings
												SCREAMING_SNAKE_CASE           =    type_vocab_size
												SCREAMING_SNAKE_CASE           =    type_sequence_label_size
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    num_choices




							def 		__snake_case(  self				:   Any )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size, self.seq_length]		,							self.vocab_size )

												SCREAMING_SNAKE_CASE           =    None
												if self.use_attention_mask:
																	SCREAMING_SNAKE_CASE           =    random_attention_mask([self.batch_size, self.seq_length] )

												SCREAMING_SNAKE_CASE           =    None
												if self.use_token_type_ids:
																	SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size, self.seq_length]		,							self.type_vocab_size )

												SCREAMING_SNAKE_CASE           =    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=_UpperCamelCase		,							initializer_range=self.initializer_range		,							)

												return config, input_ids, token_type_ids, attention_mask




							def 		__snake_case(  self				:   Dict )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    config_and_inputs
												SCREAMING_SNAKE_CASE           =    {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
												return config, inputs_dict





							def 		__snake_case(  self				:   List[str] )   ->			Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    config_and_inputs

												SCREAMING_SNAKE_CASE           =    True
												SCREAMING_SNAKE_CASE           =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
												SCREAMING_SNAKE_CASE           =    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   lowercase      (       a			,    unittest.TestCase       ):
							lowercase__  :    Union[str, Any]									=							True

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




							def 		__snake_case(  self				:   Dict )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    FlaxBertModelTester(self )





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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    FlaxBertModel.from_pretrained("bert-base-cased" )
												SCREAMING_SNAKE_CASE           =    model(np.ones((1, 1) ) )
												self.assertIsNotNone(_UpperCamelCase )





from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_herbert import HerbertTokenizer


_lowerCamelCase   :				Optional[Any]     			=						logging.get_logger(__name__)

_lowerCamelCase   :				Any     			=						{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

_lowerCamelCase   :				int     			=						{
    '''vocab_file''': {
        '''allegro/herbert-base-cased''': '''https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json'''
    },
    '''merges_file''': {
        '''allegro/herbert-base-cased''': '''https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt'''
    },
}

_lowerCamelCase   :				Tuple     			=						{'''allegro/herbert-base-cased''': 5_14}
_lowerCamelCase   :				Optional[int]     			=						{}


class   lowercase      (       a       ):
							lowercase__  :    List[str]									=							VOCAB_FILES_NAMES
							lowercase__  :    str									=							PRETRAINED_VOCAB_FILES_MAP
							lowercase__  :    Tuple									=							PRETRAINED_INIT_CONFIGURATION
							lowercase__  :    Optional[int]									=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase__  :    str									=							HerbertTokenizer




							def __init__(  self				:   Dict		,							_UpperCamelCase				:   Any=None		,							_UpperCamelCase				:   Any=None		,							_UpperCamelCase				:   Optional[int]=None		,							_UpperCamelCase				:   Optional[int]="<s>"		,							_UpperCamelCase				:   Union[str, Any]="<unk>"		,							_UpperCamelCase				:   List[str]="<pad>"		,							_UpperCamelCase				:   List[str]="<mask>"		,							_UpperCamelCase				:   Tuple="</s>"		,							**_UpperCamelCase				:   Any		,							)   ->			str:



												'''simple docstring'''

												super().__init__(
												    _UpperCamelCase		,							_UpperCamelCase		,							tokenizer_file=_UpperCamelCase		,							cls_token=_UpperCamelCase		,							unk_token=_UpperCamelCase		,							pad_token=_UpperCamelCase		,							mask_token=_UpperCamelCase		,							sep_token=_UpperCamelCase		,							**_UpperCamelCase		,							)




							def 		__snake_case(  self				:   Optional[Any]		,							_UpperCamelCase				:   List[int]		,							_UpperCamelCase				:   Optional[List[int]] = None )   ->			List[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    [self.cls_token_id]
												SCREAMING_SNAKE_CASE           =    [self.sep_token_id]
												if token_ids_a is None:
																	return cls + token_ids_a + sep

												return cls + token_ids_a + sep + token_ids_a + sep




							def 		__snake_case(  self				:   Any		,							_UpperCamelCase				:   List[int]		,							_UpperCamelCase				:   Optional[List[int]] = None		,							_UpperCamelCase				:   bool = False )   ->			List[int]:



												'''simple docstring'''

												if already_has_special_tokens:
																	return super().get_special_tokens_mask(
																	    token_ids_a=_UpperCamelCase		,							token_ids_a=_UpperCamelCase		,							already_has_special_tokens=_UpperCamelCase )

												if token_ids_a is None:
																	return [1] + ([0] * len(_UpperCamelCase )) + [1]
												return [1] + ([0] * len(_UpperCamelCase )) + [1] + ([0] * len(_UpperCamelCase )) + [1]




							def 		__snake_case(  self				:   Union[str, Any]		,							_UpperCamelCase				:   List[int]		,							_UpperCamelCase				:   Optional[List[int]] = None )   ->			List[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    [self.sep_token_id]
												SCREAMING_SNAKE_CASE           =    [self.cls_token_id]

												if token_ids_a is None:
																	return len(cls + token_ids_a + sep ) * [0]
												return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]





							def 		__snake_case(  self				:   str		,							_UpperCamelCase				:   str		,							_UpperCamelCase				:   Optional[str] = None )   ->			Tuple[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self._tokenizer.model.save(_UpperCamelCase		,							name=_UpperCamelCase )
												return tuple(_UpperCamelCase )




