




'''simple docstring'''

import random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
							import os

							import jax.numpy as jnp
							from jax import jit

							from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
							from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

							a  :				int									=  '0.12'  # assumed parallelism: 8


if is_torch_available():
							import torch


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase=None	)		->					List[Any]:

					'''simple docstring'''

					if rng is None:
										snake_case_									=				random.Random()

					snake_case_									=				1
					for dim in shape:
										total_dims *= dim

					snake_case_									=				[]
					for _ in range(__UpperCAmelCase	):
										values.append(rng.randint(0,      vocab_size - 1	)	)

					snake_case_									=				np.array(__UpperCAmelCase,      dtype=jnp.intaa	).reshape(__UpperCAmelCase	)

					return output


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase=None	)		->					List[Any]:

					'''simple docstring'''

					snake_case_									=				ids_tensor(__UpperCAmelCase,      vocab_size=2,      rng=__UpperCAmelCase	)
					# make sure that at least one token is attended to for each batch
					snake_case_									=				1
					return attn_mask






@require_flax
class 						a				:
				snake_case_      =		None
				snake_case_      =		()


				def   A_ (		self    :					Tuple					):
									snake_case_			,snake_case_									=				self.model_tester.prepare_config_and_inputs_for_common()

									# cut to half length & take max batch_size 3
									snake_case_									=				2
									snake_case_									=				inputs['''input_ids'''].shape[-1] // 2
									snake_case_									=				inputs['''input_ids'''][:max_batch_size, :sequence_length]

									snake_case_									=				jnp.ones_like(lowercase_					)
									snake_case_									=				attention_mask[:max_batch_size, :sequence_length]

									# generate max 5 tokens
									snake_case_									=				input_ids.shape[-1] + 5
									if config.eos_token_id is not None and config.pad_token_id is None:
														# hack to allow generate for models such as GPT2 as is done in `generate()`
														snake_case_									=				config.eos_token_id
									return config, input_ids, attention_mask, max_length


				@is_pt_flax_cross_test
				def   A_ (		self    :					int					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				False
									snake_case_									=				max_length
									snake_case_									=				0

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model_class.__name__[4:]  # Skip the "Flax" at the beginning
														snake_case_									=				getattr(lowercase_       ,				lowercase_					)
														snake_case_									=				pt_model_class(lowercase_					).eval()
														snake_case_									=				load_flax_weights_in_pytorch_model(lowercase_       ,				flax_model.params					)

														snake_case_									=				flax_model.generate(lowercase_					).sequences
														snake_case_									=				pt_model.generate(torch.tensor(lowercase_       ,				dtype=torch.long					)					)

														if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
																			snake_case_									=				flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

														self.assertListEqual(pt_generation_outputs.numpy().tolist()       ,				flax_generation_outputs.tolist()					)


				def   A_ (		self    :					Dict					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				False
									snake_case_									=				max_length

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Optional[int]					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				True
									snake_case_									=				max_length

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Optional[Any]					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				False
									snake_case_									=				max_length
									snake_case_									=				2

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Optional[int]					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				False
									snake_case_									=				max_length
									snake_case_									=				2
									snake_case_									=				2

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[0]       ,				input_ids.shape[0] * config.num_return_sequences					)


				def   A_ (		self    :					Union[str, Any]					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				True
									snake_case_									=				max_length
									snake_case_									=				0.8
									snake_case_									=				10
									snake_case_									=				0.3
									snake_case_									=				1
									snake_case_									=				8
									snake_case_									=				9

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Tuple					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				max_length
									snake_case_									=				1
									snake_case_									=				8
									snake_case_									=				9

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Dict					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()
									snake_case_									=				max_length
									snake_case_									=				2
									snake_case_									=				1
									snake_case_									=				8
									snake_case_									=				9

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					int					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()

									# pad attention mask on the left
									snake_case_									=				attention_mask.at[(0, 0)].set(0					)

									snake_case_									=				False
									snake_case_									=				max_length

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_       ,				attention_mask=lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_       ,				attention_mask=lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					Union[str, Any]					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()

									# pad attention mask on the left
									snake_case_									=				attention_mask.at[(0, 0)].set(0					)

									snake_case_									=				True
									snake_case_									=				max_length

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_       ,				attention_mask=lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_       ,				attention_mask=lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)


				def   A_ (		self    :					str					):
									snake_case_			,snake_case_			,snake_case_			,snake_case_									=				self._get_input_ids_and_config()

									# pad attention mask on the left
									snake_case_									=				attention_mask.at[(0, 0)].set(0					)

									snake_case_									=				2
									snake_case_									=				max_length

									for model_class in self.all_generative_model_classes:
														snake_case_									=				model_class(lowercase_					)

														snake_case_									=				model.generate(lowercase_       ,				attention_mask=lowercase_					).sequences
														self.assertEqual(generation_outputs.shape[-1]       ,				lowercase_					)

														snake_case_									=				jit(model.generate					)
														snake_case_									=				jit_generate(lowercase_       ,				attention_mask=lowercase_					).sequences

														self.assertListEqual(generation_outputs.tolist()       ,				jit_generation_outputs.tolist()					)







@require_flax
class 						a				(   unittest.TestCase     ):


				def   A_ (		self    :					int					):
									snake_case_									=				AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-bert'''					)
									snake_case_									=				FlaxAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-bert-flax-only'''					)

									snake_case_									=				'''Hello world'''
									snake_case_									=				tokenizer(lowercase_       ,				return_tensors='''np'''					).input_ids

									# typos are quickly detected (the correct argument is `do_sample`)
									with self.assertRaisesRegex(lowercase_       ,				'''do_samples'''					):
														model.generate(lowercase_       ,				do_samples=lowercase_					)

									# arbitrary arguments that will not be used anywhere are also not accepted
									with self.assertRaisesRegex(lowercase_       ,				'''foo'''					):
														snake_case_									=				{'''foo''': '''bar'''}
														model.generate(lowercase_       ,				**lowercase_					)







'''simple docstring'''

import re


def 		__magic_name__    (	__UpperCAmelCase	)		->					bool:

					'''simple docstring'''

					snake_case_									=				re.compile(
					    r'''^(?:0|94|\+94|0{2}94)''' r'''7(0|1|2|4|5|6|7|8)''' r'''(-| |)''' r'''\d{7}$'''	)

					return bool(re.search(__UpperCAmelCase,      __UpperCAmelCase	)	)


if __name__ == "__main__":
							a  :				Any									=  '0094702343221'

							print(is_sri_lankan_phone_number(phone))

