

'''simple docstring'''



import tempfile
import unittest

import numpy as np
from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_flax


if is_flax_available():
		import os

		from flax.core.frozen_dict import unfreeze
		from flax.traverse_util import flatten_dict

		from transformers import FlaxBertModel

		__snake_case			:     Tuple										=      '0.12'  # assumed parallelism: 8



@require_flax
@is_staging_test
class lowerCamelCase			(  unittest.TestCase						):



			'''simple docstring'''






			@classmethod
			def lowercase__						(				cls	:						List[str]			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Optional[int]     =TOKEN
									HfFolder.save_token(lowerCAmelCase_			)


			@classmethod
			def lowercase__						(				cls	:						int			)      ->		Tuple:





									'''simple docstring'''
									try:
															delete_repo(token=cls._token		,      repo_id="""test-model-flax"""			)
									except HTTPError:
															pass

									try:
															delete_repo(token=cls._token		,      repo_id="""valid_org/test-model-flax-org"""			)
									except HTTPError:
															pass


			def lowercase__						(				self	:						List[Any]			)      ->		int:





									'''simple docstring'''
									A__					:       Any     =BertConfig(
									    vocab_size=99		,      hidden_size=32		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=37			)
									A__					:       List[str]     =FlaxBertModel(lowerCAmelCase_			)
									model.push_to_hub("""test-model-flax"""		,      use_auth_token=self._token			)

									A__					:       Optional[Any]     =FlaxBertModel.from_pretrained(f"{USER}/test-model-flax"			)

									A__					:       Tuple     =flatten_dict(unfreeze(model.params			)			)
									A__					:       List[str]     =flatten_dict(unfreeze(new_model.params			)			)

									for key in base_params.keys():
															A__					:       str     =(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(lowerCAmelCase_		,      1e-3		,      msg=f"{key} not identical"			)

									# Reset repo
									delete_repo(token=self._token		,      repo_id="""test-model-flax"""			)

									# Push to hub via save_pretrained
									with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(lowerCAmelCase_		,      repo_id="""test-model-flax"""		,      push_to_hub=lowerCAmelCase_		,      use_auth_token=self._token			)

									A__					:       str     =FlaxBertModel.from_pretrained(f"{USER}/test-model-flax"			)

									A__					:       Optional[Any]     =flatten_dict(unfreeze(model.params			)			)
									A__					:       Optional[int]     =flatten_dict(unfreeze(new_model.params			)			)

									for key in base_params.keys():
															A__					:       Optional[int]     =(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(lowerCAmelCase_		,      1e-3		,      msg=f"{key} not identical"			)



			def lowercase__						(				self	:						List[str]			)      ->		Optional[int]:





									'''simple docstring'''
									A__					:       List[Any]     =BertConfig(
									    vocab_size=99		,      hidden_size=32		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=37			)
									A__					:       Tuple     =FlaxBertModel(lowerCAmelCase_			)
									model.push_to_hub("""valid_org/test-model-flax-org"""		,      use_auth_token=self._token			)

									A__					:       int     =FlaxBertModel.from_pretrained("""valid_org/test-model-flax-org"""			)

									A__					:       str     =flatten_dict(unfreeze(model.params			)			)
									A__					:       List[str]     =flatten_dict(unfreeze(new_model.params			)			)

									for key in base_params.keys():
															A__					:       List[str]     =(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(lowerCAmelCase_		,      1e-3		,      msg=f"{key} not identical"			)

									# Reset repo
									delete_repo(token=self._token		,      repo_id="""valid_org/test-model-flax-org"""			)

									# Push to hub via save_pretrained
									with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(
															    lowerCAmelCase_		,      repo_id="""valid_org/test-model-flax-org"""		,      push_to_hub=lowerCAmelCase_		,      use_auth_token=self._token			)

									A__					:       List[Any]     =FlaxBertModel.from_pretrained("""valid_org/test-model-flax-org"""			)

									A__					:       Union[str, Any]     =flatten_dict(unfreeze(model.params			)			)
									A__					:       Union[str, Any]     =flatten_dict(unfreeze(new_model.params			)			)

									for key in base_params.keys():
															A__					:       Any     =(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(lowerCAmelCase_		,      1e-3		,      msg=f"{key} not identical"			)


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






						"""simple docstring"""





						A__					:       List[str]     =True
						A__					:       Tuple     =flatten_dict(modela.params	)
						A__					:       str     =flatten_dict(modela.params	)
						for key in flat_params_a.keys():
												if np.sum(np.abs(flat_params_a[key] - flat_params_a[key]	)	) > 1E-4:
																		A__					:       Optional[int]     =False

						return models_are_equal



@require_flax
class lowerCamelCase			(  unittest.TestCase						):



			'''simple docstring'''






			def lowercase__						(				self	:						str			)      ->		Tuple:





									'''simple docstring'''
									A__					:       List[str]     =BertConfig.from_pretrained("""hf-internal-testing/tiny-bert-flax-only"""			)
									A__					:       Any     =FlaxBertModel(lowerCAmelCase_			)

									A__					:       str     ="""bert"""
									with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(os.path.join(lowerCAmelCase_		,      lowerCAmelCase_			)			)

															with self.assertRaises(lowerCAmelCase_			):
																					A__					:       Dict     =FlaxBertModel.from_pretrained(lowerCAmelCase_			)

															A__					:       Tuple     =FlaxBertModel.from_pretrained(lowerCAmelCase_		,      subfolder=lowerCAmelCase_			)

									self.assertTrue(check_models_equal(lowerCAmelCase_		,      lowerCAmelCase_			)			)


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





									'''simple docstring'''
									A__					:       List[Any]     =BertConfig.from_pretrained("""hf-internal-testing/tiny-bert-flax-only"""			)
									A__					:       Union[str, Any]     =FlaxBertModel(lowerCAmelCase_			)

									A__					:       Tuple     ="""bert"""
									with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(os.path.join(lowerCAmelCase_		,      lowerCAmelCase_			)		,      max_shard_size="""10KB"""			)

															with self.assertRaises(lowerCAmelCase_			):
																					A__					:       int     =FlaxBertModel.from_pretrained(lowerCAmelCase_			)

															A__					:       Tuple     =FlaxBertModel.from_pretrained(lowerCAmelCase_		,      subfolder=lowerCAmelCase_			)

									self.assertTrue(check_models_equal(lowerCAmelCase_		,      lowerCAmelCase_			)			)


			def lowercase__						(				self	:						Dict			)      ->		Any:





									'''simple docstring'''
									A__					:       Optional[Any]     ="""bert"""
									A__					:       int     ="""hf-internal-testing/tiny-random-bert-subfolder"""

									with self.assertRaises(lowerCAmelCase_			):
															A__					:       int     =FlaxBertModel.from_pretrained(lowerCAmelCase_			)

									A__					:       Tuple     =FlaxBertModel.from_pretrained(lowerCAmelCase_		,      subfolder=lowerCAmelCase_			)

									self.assertIsNotNone(lowerCAmelCase_			)



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





									'''simple docstring'''
									A__					:       List[str]     ="""bert"""
									A__					:       Tuple     ="""hf-internal-testing/tiny-random-bert-sharded-subfolder"""
									with self.assertRaises(lowerCAmelCase_			):
															A__					:       List[str]     =FlaxBertModel.from_pretrained(lowerCAmelCase_			)

									A__					:       List[Any]     =FlaxBertModel.from_pretrained(lowerCAmelCase_		,      subfolder=lowerCAmelCase_			)

									self.assertIsNotNone(lowerCAmelCase_			)




'''simple docstring'''



import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class lowerCamelCase			(  lowercase_						):



			'''simple docstring'''






			__snake_case        =	['image_processor', 'tokenizer']
			__snake_case        =	'FlavaImageProcessor'
			__snake_case        =	('BertTokenizer', 'BertTokenizerFast')


			def __init__(				self	:						Optional[int]		,      lowerCAmelCase_	:						List[str]=None		,      lowerCAmelCase_	:						Optional[Any]=None		,      **lowerCAmelCase_	:						Optional[Any]			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Any     =None
									if "feature_extractor" in kwargs:
															warnings.warn(
															    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
															    """ instead."""		,      lowerCAmelCase_		,      )
															A__					:       Optional[Any]     =kwargs.pop("""feature_extractor"""			)

									A__					:       List[Any]     =image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
															raise ValueError("""You need to specify an `image_processor`."""			)
									if tokenizer is None:
															raise ValueError("""You need to specify a `tokenizer`."""			)

									super().__init__(lowerCAmelCase_		,      lowerCAmelCase_			)
									A__					:       int     =self.image_processor


			def __call__(				self	:						Union[str, Any]		,      lowerCAmelCase_	:						Optional[ImageInput] = None		,      lowerCAmelCase_	:						Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None		,      lowerCAmelCase_	:						bool = True		,      lowerCAmelCase_	:						Union[bool, str, PaddingStrategy] = False		,      lowerCAmelCase_	:						Union[bool, str, TruncationStrategy] = False		,      lowerCAmelCase_	:						Optional[int] = None		,      lowerCAmelCase_	:						int = 0		,      lowerCAmelCase_	:						Optional[int] = None		,      lowerCAmelCase_	:						Optional[bool] = None		,      lowerCAmelCase_	:						Optional[bool] = None		,      lowerCAmelCase_	:						Optional[bool] = None		,      lowerCAmelCase_	:						Optional[bool] = None		,      lowerCAmelCase_	:						bool = False		,      lowerCAmelCase_	:						bool = False		,      lowerCAmelCase_	:						bool = False		,      lowerCAmelCase_	:						bool = False		,      lowerCAmelCase_	:						bool = True		,      lowerCAmelCase_	:						Optional[Union[str, TensorType]] = None		,      **lowerCAmelCase_	:						Optional[int]		,      )      ->		str:





									'''simple docstring'''

									if text is None and images is None:
															raise ValueError("""You have to specify either text or images. Both cannot be none."""			)

									if text is not None:
															A__					:       int     =self.tokenizer(
															    text=lowerCAmelCase_		,      add_special_tokens=lowerCAmelCase_		,      padding=lowerCAmelCase_		,      truncation=lowerCAmelCase_		,      max_length=lowerCAmelCase_		,      stride=lowerCAmelCase_		,      pad_to_multiple_of=lowerCAmelCase_		,      return_token_type_ids=lowerCAmelCase_		,      return_attention_mask=lowerCAmelCase_		,      return_overflowing_tokens=lowerCAmelCase_		,      return_special_tokens_mask=lowerCAmelCase_		,      return_offsets_mapping=lowerCAmelCase_		,      return_length=lowerCAmelCase_		,      verbose=lowerCAmelCase_		,      return_tensors=lowerCAmelCase_		,      **lowerCAmelCase_		,      )
									if images is not None:
															A__					:       List[str]     =self.image_processor(
															    lowerCAmelCase_		,      return_image_mask=lowerCAmelCase_		,      return_codebook_pixels=lowerCAmelCase_		,      return_tensors=lowerCAmelCase_		,      **lowerCAmelCase_		,      )

									if text is not None and images is not None:
															encoding.update(lowerCAmelCase_			)
															return encoding
									elif text is not None:
															return encoding
									else:
															return BatchEncoding(data=dict(**lowerCAmelCase_			)		,      tensor_type=lowerCAmelCase_			)


			def lowercase__						(				self	:						Any		,      *lowerCAmelCase_	:						str		,      **lowerCAmelCase_	:						Optional[int]			)      ->		str:





									'''simple docstring'''
									return self.tokenizer.batch_decode(*lowerCAmelCase_		,      **lowerCAmelCase_			)


			def lowercase__						(				self	:						List[Any]		,      *lowerCAmelCase_	:						List[Any]		,      **lowerCAmelCase_	:						Any			)      ->		Tuple:





									'''simple docstring'''
									return self.tokenizer.decode(*lowerCAmelCase_		,      **lowerCAmelCase_			)


			@property
			def lowercase__						(				self	:						Tuple			)      ->		Tuple:





									'''simple docstring'''
									A__					:       Any     =self.tokenizer.model_input_names
									A__					:       Optional[Any]     =self.image_processor.model_input_names
									return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names			)			)


			@property
			def lowercase__						(				self	:						Tuple			)      ->		int:





									'''simple docstring'''
									warnings.warn(
									    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""		,      lowerCAmelCase_		,      )
									return self.image_processor_class



			@property
			def lowercase__						(				self	:						Tuple			)      ->		Dict:





									'''simple docstring'''
									warnings.warn(
									    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""		,      lowerCAmelCase_		,      )
									return self.image_processor

