

'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TFLEDForConditionalGeneration, TFLEDModel







@require_tf
class     UpperCamelCase__       :


		"""simple docstring"""

		SCREAMING_SNAKE_CASE__    :      Optional[Any]  =				LEDConfig
		SCREAMING_SNAKE_CASE__    :      int  =				{}
		SCREAMING_SNAKE_CASE__    :      Any  =				'gelu'







		def __init__(					self       ,     snake_case       ,     snake_case=1_3       ,     snake_case=7       ,     snake_case=True       ,     snake_case=False       ,     snake_case=9_9       ,     snake_case=3_2       ,     snake_case=2       ,     snake_case=4       ,     snake_case=3_7       ,     snake_case=0.1       ,     snake_case=0.1       ,     snake_case=2_0       ,     snake_case=2       ,     snake_case=1       ,     snake_case=0       ,     snake_case=4       ,     ):


							'''simple docstring'''

							UpperCAmelCase						:				int     =  parent
							UpperCAmelCase						:				Any     =  batch_size
							UpperCAmelCase						:				Optional[int]     =  seq_length
							UpperCAmelCase						:				Dict     =  is_training
							UpperCAmelCase						:				Dict     =  use_labels
							UpperCAmelCase						:				List[Any]     =  vocab_size
							UpperCAmelCase						:				List[Any]     =  hidden_size
							UpperCAmelCase						:				List[str]     =  num_hidden_layers
							UpperCAmelCase						:				List[Any]     =  num_attention_heads
							UpperCAmelCase						:				int     =  intermediate_size

							UpperCAmelCase						:				List[Any]     =  hidden_dropout_prob
							UpperCAmelCase						:				List[Any]     =  attention_probs_dropout_prob
							UpperCAmelCase						:				Tuple     =  max_position_embeddings
							UpperCAmelCase						:				Dict     =  eos_token_id
							UpperCAmelCase						:				Tuple     =  pad_token_id
							UpperCAmelCase						:				List[str]     =  bos_token_id
							UpperCAmelCase						:				Dict     =  attention_window

							# `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
							# [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
							# returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
							# because its local attention only attends to `self.attention_window` and one before and one after
							UpperCAmelCase						:				str     =  self.attention_window + 2

							# because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
							# the `test_attention_outputs` and `test_hidden_states_output` tests
							UpperCAmelCase						:				Union[str, Any]     =  (
							    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
							)







		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase						:				Optional[int]     =  ids_tensor([self.batch_size, self.seq_length - 1]       ,     self.vocab_size     )
							UpperCAmelCase						:				Any     =  tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size     )       ,     1     )
							UpperCAmelCase						:				List[Any]     =  tf.concat([input_ids, eos_tensor]       ,     axis=1     )

							UpperCAmelCase						:				Optional[Any]     =  ids_tensor([self.batch_size, self.seq_length]       ,     self.vocab_size     )

							UpperCAmelCase						:				Union[str, Any]     =  self.config_cls(
							    vocab_size=self.vocab_size       ,     d_model=self.hidden_size       ,     encoder_layers=self.num_hidden_layers       ,     decoder_layers=self.num_hidden_layers       ,     encoder_attention_heads=self.num_attention_heads       ,     decoder_attention_heads=self.num_attention_heads       ,     encoder_ffn_dim=self.intermediate_size       ,     decoder_ffn_dim=self.intermediate_size       ,     dropout=self.hidden_dropout_prob       ,     attention_dropout=self.attention_probs_dropout_prob       ,     max_position_embeddings=self.max_position_embeddings       ,     eos_token_ids=[2]       ,     bos_token_id=self.bos_token_id       ,     pad_token_id=self.pad_token_id       ,     decoder_start_token_id=self.pad_token_id       ,     attention_window=self.attention_window       ,     **self.config_updates       ,     )
							UpperCAmelCase						:				Tuple     =  prepare_led_inputs_dict(snake_case       ,     snake_case       ,     snake_case     )
							UpperCAmelCase						:				int     =  tf.concat(
							    [tf.zeros_like(snake_case     )[:, :-1], tf.ones_like(snake_case     )[:, -1:]]       ,     axis=-1       ,     )
							UpperCAmelCase						:				Union[str, Any]     =  global_attention_mask
							return config, inputs_dict







		def  A_			(					self       ,     snake_case       ,     snake_case     ):


							'''simple docstring'''

							UpperCAmelCase						:				Dict     =  TFLEDModel(config=snake_case     ).get_decoder()
							UpperCAmelCase						:				str     =  inputs_dict["input_ids"]

							UpperCAmelCase						:				Any     =  input_ids[:1, :]
							UpperCAmelCase						:				Dict     =  inputs_dict["attention_mask"][:1, :]
							UpperCAmelCase						:				Dict     =  1

							# first forward pass
							UpperCAmelCase						:				Any     =  model(snake_case       ,     attention_mask=snake_case       ,     use_cache=snake_case     )

							UpperCAmelCase   ,					UpperCAmelCase						:				Dict     =  outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							UpperCAmelCase						:				Optional[int]     =  ids_tensor((self.batch_size, 3)       ,     config.vocab_size     )
							UpperCAmelCase						:				str     =  tf.cast(ids_tensor((self.batch_size, 3)       ,     2     )       ,     tf.inta     )

							# append to next input_ids and
							UpperCAmelCase						:				Optional[int]     =  tf.concat([input_ids, next_tokens]       ,     axis=-1     )
							UpperCAmelCase						:				Optional[int]     =  tf.concat([attention_mask, next_attn_mask]       ,     axis=-1     )

							UpperCAmelCase						:				Union[str, Any]     =  model(snake_case       ,     attention_mask=snake_case     )[0]
							UpperCAmelCase						:				int     =  model(snake_case       ,     attention_mask=snake_case       ,     past_key_values=snake_case     )[0]

							self.parent.assertEqual(next_tokens.shape[1]       ,     output_from_past.shape[1]     )

							# select random slice
							UpperCAmelCase						:				Dict     =  int(ids_tensor((1,)       ,     output_from_past.shape[-1]     )     )
							UpperCAmelCase						:				str     =  output_from_no_past[:, -3:, random_slice_idx]
							UpperCAmelCase						:				List[str]     =  output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(snake_case       ,     snake_case       ,     rtol=1e-3     )





def  lowercase   (	__magic_name__					,       __magic_name__					,       __magic_name__					,       __magic_name__=None					,       __magic_name__=None					,       __magic_name__=None					,       __magic_name__=None					,       ):



					'''simple docstring'''







					if attention_mask is None:
										UpperCAmelCase						:				List[str]     =  tf.cast(tf.math.not_equal(A__					,       config.pad_token_id				)					,       tf.inta				)
					if decoder_attention_mask is None:
										UpperCAmelCase						:				str     =  tf.concat(
										    [
										        tf.ones(decoder_input_ids[:, :1].shape					,       dtype=tf.inta				),
										        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]					,       config.pad_token_id				)					,       tf.inta				),
										    ]					,       axis=-1					,       )
					if head_mask is None:
										UpperCAmelCase						:				Union[str, Any]     =  tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
					if decoder_head_mask is None:
										UpperCAmelCase						:				Optional[int]     =  tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
					return {
					    "input_ids": input_ids,
					    "attention_mask": attention_mask,
					    "decoder_input_ids": decoder_input_ids,
					    "decoder_attention_mask": decoder_attention_mask,
					    "head_mask": head_mask,
					    "decoder_head_mask": decoder_head_mask,
					}







@require_tf
class     UpperCamelCase__       (  UpperCamelCase__				,				UpperCamelCase__				,				unittest.TestCase  ):


		"""simple docstring"""

		SCREAMING_SNAKE_CASE__    :      Optional[Any]  =				(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
		SCREAMING_SNAKE_CASE__    :      Union[str, Any]  =				(TFLEDForConditionalGeneration,) if is_tf_available() else ()
		SCREAMING_SNAKE_CASE__    :      List[Any]  =				(
		    {
		        'conversational': TFLEDForConditionalGeneration,
		        'feature-extraction': TFLEDModel,
		        'summarization': TFLEDForConditionalGeneration,
		        'text2text-generation': TFLEDForConditionalGeneration,
		        'translation': TFLEDForConditionalGeneration,
		    }
		    if is_tf_available()
		    else {}
		)
		SCREAMING_SNAKE_CASE__    :      Optional[int]  =				True
		SCREAMING_SNAKE_CASE__    :      Tuple  =				False
		SCREAMING_SNAKE_CASE__    :      Any  =				False
		SCREAMING_SNAKE_CASE__    :      List[str]  =				False







		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase						:				List[str]     =  TFLEDModelTester(self     )
							UpperCAmelCase						:				Union[str, Any]     =  ConfigTester(self       ,     config_class=snake_case     )







		def  A_			(					self     ):


							'''simple docstring'''

							self.config_tester.run_common_tests()







		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase						:				Union[str, Any]     =  self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*snake_case     )







		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase   ,					UpperCAmelCase						:				int     =  self.model_tester.prepare_config_and_inputs_for_common()
							UpperCAmelCase						:				List[str]     =  tf.zeros_like(inputs_dict["attention_mask"]     )
							UpperCAmelCase						:				Optional[int]     =  2
							UpperCAmelCase						:				Dict     =  tf.where(
							    tf.range(self.model_tester.seq_length     )[None, :] < num_global_attn_indices       ,     1       ,     inputs_dict["global_attention_mask"]       ,     )

							UpperCAmelCase						:				Optional[Any]     =  True
							UpperCAmelCase						:				List[str]     =  self.model_tester.seq_length
							UpperCAmelCase						:				Dict     =  self.model_tester.encoder_seq_length

							def check_decoder_attentions_output(snake_case     ):
												UpperCAmelCase						:				List[str]     =  outputs.decoder_attentions
												self.assertEqual(len(snake_case     )       ,     self.model_tester.num_hidden_layers     )
												self.assertListEqual(
												    list(decoder_attentions[0].shape[-3:]     )       ,     [self.model_tester.num_attention_heads, seq_length, seq_length]       ,     )

							def check_encoder_attentions_output(snake_case     ):
												UpperCAmelCase						:				Dict     =  [t.numpy() for t in outputs.encoder_attentions]
												UpperCAmelCase						:				Union[str, Any]     =  [t.numpy() for t in outputs.encoder_global_attentions]
												self.assertEqual(len(snake_case     )       ,     self.model_tester.num_hidden_layers     )
												self.assertEqual(len(snake_case     )       ,     self.model_tester.num_hidden_layers     )
												self.assertListEqual(
												    list(attentions[0].shape[-3:]     )       ,     [self.model_tester.num_attention_heads, seq_length, seq_length]       ,     )
												self.assertListEqual(
												    list(global_attentions[0].shape[-3:]     )       ,     [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]       ,     )

							for model_class in self.all_model_classes:
												UpperCAmelCase						:				Optional[int]     =  True
												UpperCAmelCase						:				Optional[Any]     =  False
												UpperCAmelCase						:				Optional[int]     =  False
												UpperCAmelCase						:				Union[str, Any]     =  model_class(snake_case     )
												UpperCAmelCase						:				Optional[int]     =  model(self._prepare_for_class(snake_case       ,     snake_case     )     )
												UpperCAmelCase						:				str     =  len(snake_case     )
												self.assertEqual(config.output_hidden_states       ,     snake_case     )
												check_encoder_attentions_output(snake_case     )

												if self.is_encoder_decoder:
																	UpperCAmelCase						:				Union[str, Any]     =  model_class(snake_case     )
																	UpperCAmelCase						:				List[str]     =  model(self._prepare_for_class(snake_case       ,     snake_case     )     )
																	self.assertEqual(config.output_hidden_states       ,     snake_case     )
																	check_decoder_attentions_output(snake_case     )

												# Check that output attentions can also be changed via the config
												del inputs_dict["output_attentions"]
												UpperCAmelCase						:				List[str]     =  True
												UpperCAmelCase						:				str     =  model_class(snake_case     )
												UpperCAmelCase						:				Any     =  model(self._prepare_for_class(snake_case       ,     snake_case     )     )
												self.assertEqual(config.output_hidden_states       ,     snake_case     )
												check_encoder_attentions_output(snake_case     )

												# Check attention is always last and order is fine
												UpperCAmelCase						:				int     =  True
												UpperCAmelCase						:				Optional[int]     =  True
												UpperCAmelCase						:				int     =  model_class(snake_case     )
												UpperCAmelCase						:				List[str]     =  model(self._prepare_for_class(snake_case       ,     snake_case     )     )

												self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)       ,     len(snake_case     )     )
												self.assertEqual(model.config.output_hidden_states       ,     snake_case     )
												check_encoder_attentions_output(snake_case     )







		@unittest.skip("LED keeps using potentially symbolic tensors in conditionals and breaks tracing."     )
		def  A_			(					self     ):


							'''simple docstring'''

							pass







		def  A_			(					self     ):


							'''simple docstring'''

							pass





def  lowercase   (	__magic_name__				):



					'''simple docstring'''







					return tf.constant(A__					,       dtype=tf.intaa				)


a  :     Tuple    			=					1E-4







@slow
@require_tf
class     UpperCamelCase__       (  unittest.TestCase  ):


		"""simple docstring"""

		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase						:				int     =  TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"     ).led

							# change to intended input here
							UpperCAmelCase						:				int     =  _long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]     )
							UpperCAmelCase						:				Union[str, Any]     =  _long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]     )
							UpperCAmelCase						:				Optional[Any]     =  prepare_led_inputs_dict(model.config       ,     snake_case       ,     snake_case     )
							UpperCAmelCase						:				Optional[Any]     =  model(**snake_case     )[0]
							UpperCAmelCase						:				List[str]     =  (1, 1_0_2_4, 7_6_8)
							self.assertEqual(output.shape       ,     snake_case     )
							# change to expected output here
							UpperCAmelCase						:				Union[str, Any]     =  tf.convert_to_tensor(
							    [[2.3050, 2.8279, 0.6531], [-1.8457, -0.1455, -3.5661], [-1.0186, 0.4586, -2.2043]]       ,     )
							tf.debugging.assert_near(output[:, :3, :3]       ,     snake_case       ,     atol=1e-3     )







		def  A_			(					self     ):


							'''simple docstring'''

							UpperCAmelCase						:				Optional[Any]     =  TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"     )

							# change to intended input here
							UpperCAmelCase						:				str     =  _long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]     )
							UpperCAmelCase						:				Optional[int]     =  _long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]     )
							UpperCAmelCase						:				str     =  prepare_led_inputs_dict(model.config       ,     snake_case       ,     snake_case     )
							UpperCAmelCase						:				Tuple     =  model(**snake_case     )[0]
							UpperCAmelCase						:				List[str]     =  (1, 1_0_2_4, model.config.vocab_size)
							self.assertEqual(output.shape       ,     snake_case     )
							# change to expected output here
							UpperCAmelCase						:				int     =  tf.convert_to_tensor(
							    [[33.6507, 6.4572, 16.8089], [5.8739, -2.4238, 11.2902], [-3.2139, -4.3149, 4.2783]]       ,     )
							tf.debugging.assert_near(output[:, :3, :3]       ,     snake_case       ,     atol=1e-3       ,     rtol=1e-3     )


'''simple docstring'''
import re






def      UpperCamelCase_				(      A__						):
	a_      				=						re.compile(r"""^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$"""						)
	if match := re.search(A__  ,      A__						):
		return match.string == phone
	return False


if __name__ == "__main__":
		print(indian_phone_validator('+918827897895'))
