

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

					_UpperCAmelCase		:       str						    =	"""0.12"""  # assumed parallelism: 8







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




				@classmethod
				def    a							( cls	):
											snake_case_          =   TOKEN
											HfFolder.save_token(_a	)




				@classmethod
				def    a							( cls	):
											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    a							( self	):
											snake_case_          =   BertConfig(
											    vocab_size=99				,       hidden_size=32				,       num_hidden_layers=5				,       num_attention_heads=4				,       intermediate_size=37	)
											snake_case_          =   FlaxBertModel(_a	)
											model.push_to_hub('test-model-flax'				,       use_auth_token=self._token	)

											snake_case_          =   FlaxBertModel.from_pretrained(F'''{USER}/test-model-flax'''	)

											snake_case_          =   flatten_dict(unfreeze(model.params	)	)
											snake_case_          =   flatten_dict(unfreeze(new_model.params	)	)

											for key in base_params.keys():
																		snake_case_          =   (base_params[key] - new_params[key]).sum().item()
																		self.assertLessEqual(_a				,       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(_a				,       repo_id='test-model-flax'				,       push_to_hub=_a				,       use_auth_token=self._token	)

											snake_case_          =   FlaxBertModel.from_pretrained(F'''{USER}/test-model-flax'''	)

											snake_case_          =   flatten_dict(unfreeze(model.params	)	)
											snake_case_          =   flatten_dict(unfreeze(new_model.params	)	)

											for key in base_params.keys():
																		snake_case_          =   (base_params[key] - new_params[key]).sum().item()
																		self.assertLessEqual(_a				,       1e-3				,       msg=F'''{key} not identical'''	)




				def    a							( self	):
											snake_case_          =   BertConfig(
											    vocab_size=99				,       hidden_size=32				,       num_hidden_layers=5				,       num_attention_heads=4				,       intermediate_size=37	)
											snake_case_          =   FlaxBertModel(_a	)
											model.push_to_hub('valid_org/test-model-flax-org'				,       use_auth_token=self._token	)

											snake_case_          =   FlaxBertModel.from_pretrained('valid_org/test-model-flax-org'	)

											snake_case_          =   flatten_dict(unfreeze(model.params	)	)
											snake_case_          =   flatten_dict(unfreeze(new_model.params	)	)

											for key in base_params.keys():
																		snake_case_          =   (base_params[key] - new_params[key]).sum().item()
																		self.assertLessEqual(_a				,       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(
																		    _a				,       repo_id='valid_org/test-model-flax-org'				,       push_to_hub=_a				,       use_auth_token=self._token	)

											snake_case_          =   FlaxBertModel.from_pretrained('valid_org/test-model-flax-org'	)

											snake_case_          =   flatten_dict(unfreeze(model.params	)	)
											snake_case_          =   flatten_dict(unfreeze(new_model.params	)	)

											for key in base_params.keys():
																		snake_case_          =   (base_params[key] - new_params[key]).sum().item()
																		self.assertLessEqual(_a				,       1e-3				,       msg=F'''{key} not identical'''	)





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   True
							snake_case_          =   flatten_dict(modela.params				)
							snake_case_          =   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:
																					snake_case_          =   False

							return models_are_equal







@require_flax
class 			lowercase    (	unittest.TestCase      ):




				def    a							( self	):
											snake_case_          =   BertConfig.from_pretrained('hf-internal-testing/tiny-bert-flax-only'	)
											snake_case_          =   FlaxBertModel(_a	)

											snake_case_          =   'bert'
											with tempfile.TemporaryDirectory() as tmp_dir:
																		model.save_pretrained(os.path.join(_a				,       _a	)	)

																		with self.assertRaises(_a	):
																									snake_case_          =   FlaxBertModel.from_pretrained(_a	)

																		snake_case_          =   FlaxBertModel.from_pretrained(_a				,       subfolder=_a	)

											self.assertTrue(check_models_equal(_a				,       _a	)	)




				def    a							( self	):
											snake_case_          =   BertConfig.from_pretrained('hf-internal-testing/tiny-bert-flax-only'	)
											snake_case_          =   FlaxBertModel(_a	)

											snake_case_          =   'bert'
											with tempfile.TemporaryDirectory() as tmp_dir:
																		model.save_pretrained(os.path.join(_a				,       _a	)				,       max_shard_size='10KB'	)

																		with self.assertRaises(_a	):
																									snake_case_          =   FlaxBertModel.from_pretrained(_a	)

																		snake_case_          =   FlaxBertModel.from_pretrained(_a				,       subfolder=_a	)

											self.assertTrue(check_models_equal(_a				,       _a	)	)




				def    a							( self	):
											snake_case_          =   'bert'
											snake_case_          =   'hf-internal-testing/tiny-random-bert-subfolder'

											with self.assertRaises(_a	):
																		snake_case_          =   FlaxBertModel.from_pretrained(_a	)

											snake_case_          =   FlaxBertModel.from_pretrained(_a				,       subfolder=_a	)

											self.assertIsNotNone(_a	)




				def    a							( self	):
											snake_case_          =   'bert'
											snake_case_          =   'hf-internal-testing/tiny-random-bert-sharded-subfolder'
											with self.assertRaises(_a	):
																		snake_case_          =   FlaxBertModel.from_pretrained(_a	)

											snake_case_          =   FlaxBertModel.from_pretrained(_a				,       subfolder=_a	)

											self.assertIsNotNone(_a	)




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase		:       Tuple						    =	{
    """configuration_xlm_roberta_xl""": [
        """XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaXLConfig""",
        """XLMRobertaXLOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase		:       int						    =	[
					    """XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """XLMRobertaXLForCausalLM""",
					    """XLMRobertaXLForMaskedLM""",
					    """XLMRobertaXLForMultipleChoice""",
					    """XLMRobertaXLForQuestionAnswering""",
					    """XLMRobertaXLForSequenceClassification""",
					    """XLMRobertaXLForTokenClassification""",
					    """XLMRobertaXLModel""",
					    """XLMRobertaXLPreTrainedModel""",
					]

if TYPE_CHECKING:
					from .configuration_xlm_roberta_xl import (
					    XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    XLMRobertaXLConfig,
					    XLMRobertaXLOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm_roberta_xl import (
										    XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMRobertaXLForCausalLM,
										    XLMRobertaXLForMaskedLM,
										    XLMRobertaXLForMultipleChoice,
										    XLMRobertaXLForQuestionAnswering,
										    XLMRobertaXLForSequenceClassification,
										    XLMRobertaXLForTokenClassification,
										    XLMRobertaXLModel,
										    XLMRobertaXLPreTrainedModel,
										)

else:
					import sys

					_UpperCAmelCase		:       Optional[Any]						    =	_LazyModule(__name__, globals()["""__file__"""], _import_structure)




