





import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
      import jax

      from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
      from transformers.models.bert.modeling_flax_bert import FlaxBertModel
      from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel

@require_flax
class 	UpperCamelCase__				(   unittest.TestCase     ):



     '''simple docstring'''

     @slow
     def        SCREAMING_SNAKE_CASE__						(							self		:					Any )  ->	str:




           '''simple docstring'''


           for model_name in ["bert-base-cased", "bert-large-uncased"]:
                 with self.subTest(lowerCamelCase__ ):
                       SCREAMING_SNAKE_CASE	=		AutoConfig.from_pretrained(lowerCamelCase__ )
                       self.assertIsNotNone(lowerCamelCase__ )
                       self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__ )

                       SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained(lowerCamelCase__ )
                       self.assertIsNotNone(lowerCamelCase__ )
                       self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__ )






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




           '''simple docstring'''


           for model_name in ["roberta-base", "roberta-large"]:
                 with self.subTest(lowerCamelCase__ ):
                       SCREAMING_SNAKE_CASE	=		AutoConfig.from_pretrained(lowerCamelCase__ )
                       self.assertIsNotNone(lowerCamelCase__ )
                       self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__ )

                       SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained(lowerCamelCase__ )
                       self.assertIsNotNone(lowerCamelCase__ )
                       self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__ )






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




           '''simple docstring'''


           for model_name in ["bert-base-cased", "bert-large-uncased"]:
                 SCREAMING_SNAKE_CASE	=		AutoTokenizer.from_pretrained(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		FlaxBertModel.from_pretrained(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		tokenizer("""Do you support jax jitted function?"""		,return_tensors=TensorType.JAX )

                 @jax.jit
                 def eval(**lowerCamelCase__		:					Optional[Any] ):
                       return model(**lowerCamelCase__ )

                 eval(**lowerCamelCase__ ).block_until_ready()






     @slow
     def        SCREAMING_SNAKE_CASE__						(							self		:					str )  ->	Optional[int]:




           '''simple docstring'''


           for model_name in ["roberta-base", "roberta-large"]:
                 SCREAMING_SNAKE_CASE	=		AutoTokenizer.from_pretrained(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		FlaxRobertaModel.from_pretrained(lowerCamelCase__ )
                 SCREAMING_SNAKE_CASE	=		tokenizer("""Do you support jax jitted function?"""		,return_tensors=TensorType.JAX )

                 @jax.jit
                 def eval(**lowerCamelCase__		:					Tuple ):
                       return model(**lowerCamelCase__ )

                 eval(**lowerCamelCase__ ).block_until_ready()






     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[Any] )  ->	str:




           '''simple docstring'''


           with self.assertRaisesRegex(
               lowerCamelCase__		,"""bert-base is not a local folder and is not a valid model identifier""" ):
                 SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained("""bert-base""" )






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




           '''simple docstring'''


           with self.assertRaisesRegex(
               lowerCamelCase__		,R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ):
                 SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained(lowerCamelCase__		,revision="""aaaaaa""" )






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




           '''simple docstring'''


           with self.assertRaisesRegex(
               lowerCamelCase__		,"""hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack"""		,):
                 SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained("""hf-internal-testing/config-no-model""" )






     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple )  ->	str:




           '''simple docstring'''


           with self.assertRaisesRegex(lowerCamelCase__		,"""Use `from_pt=True` to load this model""" ):
                 SCREAMING_SNAKE_CASE	=		FlaxAutoModel.from_pretrained("""hf-internal-testing/tiny-bert-pt-only""" )









def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     float:


      '''simple docstring'''


      _validate_point(_SCREAMING_SNAKE_CASE			)
      _validate_point(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) != len(_SCREAMING_SNAKE_CASE			):
            raise ValueError("""Both points must be in the same n-dimensional space"""			)

      return float(sum(abs(a - b			) for a, b in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)			)			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     None:


      '''simple docstring'''


      if point:
            if isinstance(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			):
                  for item in point:
                        if not isinstance(_SCREAMING_SNAKE_CASE				,		(int, float)			):
                              SCREAMING_SNAKE_CASE	=		(
                                  """Expected a list of numbers as input, found """
                                  F"""{type(_SCREAMING_SNAKE_CASE			).__name__}"""
                              )
                              raise TypeError(_SCREAMING_SNAKE_CASE			)
            else:
                  SCREAMING_SNAKE_CASE	=		F"""Expected a list of numbers as input, found {type(_SCREAMING_SNAKE_CASE			).__name__}"""
                  raise TypeError(_SCREAMING_SNAKE_CASE			)
      else:
            raise ValueError("""Missing an input"""			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     float:


      '''simple docstring'''


      _validate_point(_SCREAMING_SNAKE_CASE			)
      _validate_point(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) != len(_SCREAMING_SNAKE_CASE			):
            raise ValueError("""Both points must be in the same n-dimensional space"""			)

      return float(sum(abs(x - y			) for x, y in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)			)			)


if __name__ == "__main__":
      import doctest

      doctest.testmod()


