'''simple docstring'''




import re






def 				snake_case__							(			_A:					str )    ->	bool:

		'''simple docstring'''


		lowerCAmelCase   					=  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'''))





'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available


if is_torch_available():
						import torch


if is_vision_available():
						from PIL import Image

						from transformers import MgpstrProcessor, ViTImageProcessor






@require_torch
@require_vision
class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			UpperCAmelCase_			:     Dict      =       ViTImageProcessor if is_vision_available() else None



			@property
			def 							a_       (   self):




					"""simple docstring"""


					return self.image_processor_tester.prepare_image_processor_dict()



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  (3, 32, 128)
					lowerCAmelCase   					=  tempfile.mkdtemp()

					# fmt: off
					lowerCAmelCase   					=  ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""]
					# fmt: on
					lowerCAmelCase   					=  dict(zip(__lowerCAmelCase       ,    range(len(__lowerCAmelCase))))

					lowerCAmelCase   					=  os.path.join(self.tmpdirname       ,    VOCAB_FILES_NAMES["""vocab_file"""])
					with open(self.vocab_file       ,    """w"""       ,    encoding="""utf-8""") as fp:
							fp.write(json.dumps(__lowerCAmelCase) + """\n""")

					lowerCAmelCase   					=  {
					    """do_normalize""": False,
					    """do_resize""": True,
					    """image_processor_type""": """ViTImageProcessor""",
					    """resample""": 3,
					    """size""": {"""height""": 32, """width""": 128},
					}
					lowerCAmelCase   					=  os.path.join(self.tmpdirname       ,    __lowerCAmelCase)
					with open(self.image_processor_file       ,    """w"""       ,    encoding="""utf-8""") as fp:
							json.dump(__lowerCAmelCase       ,    __lowerCAmelCase)



			def 							a_       (   self       ,    **__lowerCAmelCase):




					"""simple docstring"""


					return MgpstrTokenizer.from_pretrained(self.tmpdirname       ,    **__lowerCAmelCase)



			def 							a_       (   self       ,    **__lowerCAmelCase):




					"""simple docstring"""


					return ViTImageProcessor.from_pretrained(self.tmpdirname       ,    **__lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					shutil.rmtree(self.tmpdirname)



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  np.random.randint(255       ,    size=(3, 30, 400)       ,    dtype=np.uinta)

					lowerCAmelCase   					=  Image.fromarray(np.moveaxis(__lowerCAmelCase       ,    0       ,    -1))

					return image_input



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_tokenizer()
					lowerCAmelCase   					=  self.get_image_processor()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)
					processor.save_pretrained(self.tmpdirname)
					lowerCAmelCase   					=  MgpstrProcessor.from_pretrained(self.tmpdirname       ,    use_fast=__lowerCAmelCase)

					self.assertEqual(processor.char_tokenizer.get_vocab()       ,    tokenizer.get_vocab())
					self.assertIsInstance(processor.char_tokenizer       ,    __lowerCAmelCase)

					self.assertEqual(processor.image_processor.to_json_string()       ,    image_processor.to_json_string())
					self.assertIsInstance(processor.image_processor       ,    __lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_tokenizer()
					lowerCAmelCase   					=  self.get_image_processor()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)
					processor.save_pretrained(self.tmpdirname)

					lowerCAmelCase   					=  self.get_tokenizer(bos_token="""(BOS)"""       ,    eos_token="""(EOS)""")
					lowerCAmelCase   					=  self.get_image_processor(do_normalize=__lowerCAmelCase       ,    padding_value=1.0)

					lowerCAmelCase   					=  MgpstrProcessor.from_pretrained(
					    self.tmpdirname       ,    bos_token="""(BOS)"""       ,    eos_token="""(EOS)"""       ,    do_normalize=__lowerCAmelCase       ,    padding_value=1.0)

					self.assertEqual(processor.char_tokenizer.get_vocab()       ,    tokenizer_add_kwargs.get_vocab())
					self.assertIsInstance(processor.char_tokenizer       ,    __lowerCAmelCase)

					self.assertEqual(processor.image_processor.to_json_string()       ,    image_processor_add_kwargs.to_json_string())
					self.assertIsInstance(processor.image_processor       ,    __lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  self.prepare_image_inputs()

					lowerCAmelCase   					=  image_processor(__lowerCAmelCase       ,    return_tensors="""np""")
					lowerCAmelCase   					=  processor(images=__lowerCAmelCase       ,    return_tensors="""np""")

					for key in input_image_proc.keys():
							self.assertAlmostEqual(input_image_proc[key].sum()       ,    input_processor[key].sum()       ,    delta=1E-2)



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  """test"""

					lowerCAmelCase   					=  processor(text=__lowerCAmelCase)

					lowerCAmelCase   					=  tokenizer(__lowerCAmelCase)
					for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]       ,    encoded_processor[key])



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  """test"""
					lowerCAmelCase   					=  self.prepare_image_inputs()

					lowerCAmelCase   					=  processor(text=__lowerCAmelCase       ,    images=__lowerCAmelCase)

					self.assertListEqual(list(inputs.keys())       ,    ["""pixel_values""", """labels"""])

					# test if it raises when no input is passed
					with pytest.raises(__lowerCAmelCase):
							processor()



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]]

					lowerCAmelCase   					=  processor.char_decode(__lowerCAmelCase)
					lowerCAmelCase   					=  tokenizer.batch_decode(__lowerCAmelCase)
					lowerCAmelCase   					=  [seq.replace(""" """       ,    """""") for seq in decoded_tok]

					self.assertListEqual(__lowerCAmelCase       ,    __lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  None
					lowerCAmelCase   					=  self.prepare_image_inputs()

					lowerCAmelCase   					=  processor(text=__lowerCAmelCase       ,    images=__lowerCAmelCase)

					self.assertListEqual(list(inputs.keys())       ,    processor.model_input_names)







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_image_processor()
					lowerCAmelCase   					=  self.get_tokenizer()

					lowerCAmelCase   					=  MgpstrProcessor(tokenizer=__lowerCAmelCase       ,    image_processor=__lowerCAmelCase)

					lowerCAmelCase   					=  torch.randn(1       ,    27       ,    38)
					lowerCAmelCase   					=  torch.randn(1       ,    27       ,    50257)
					lowerCAmelCase   					=  torch.randn(1       ,    27       ,    30522)

					lowerCAmelCase   					=  processor.batch_decode([char_input, bpe_input, wp_input])

					self.assertListEqual(list(results.keys())       ,    ["""generated_text""", """scores""", """char_preds""", """bpe_preds""", """wp_preds"""])




