



import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


UpperCamelCase_									=   logging.get_logger(__name__)


UpperCamelCase_									=   {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all MVP models at https://huggingface.co/models?filter=mvp
UpperCamelCase_									=   {
    '''vocab_file''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json''',
    },
    '''added_tokens.json''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json''',
    },
    '''merges_file''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt''',
    },
}

UpperCamelCase_									=   {
    '''RUCAIBox/mvp''': 1024,
}







@lru_cache()
def       lowerCamelCase_  (    ):



    '''simple docstring'''




    UpperCAmelCase_     :       List[Any]  		=					(
        list(range(ord("""!"""    )   ,		ord("""~"""    ) + 1    )    ) + list(range(ord("""¡"""    )   ,		ord("""¬"""    ) + 1    )    ) + list(range(ord("""®"""    )   ,		ord("""ÿ"""    ) + 1    )    )
    )
    UpperCAmelCase_     :       int  		=					bs[:]
    UpperCAmelCase_     :       Union[str, Any]  		=					0
    for b in range(2**8    ):
        if b not in bs:
            bs.append(_a    )
            cs.append(2**8 + n    )
            n += 1
    UpperCAmelCase_     :       Tuple  		=					[chr(_a    ) for n in cs]
    return dict(zip(_a   ,		_a    )    )







def       lowerCamelCase_  (    _a       :						Union[str, Any]    ):



    '''simple docstring'''




    UpperCAmelCase_     :       str  		=					set()
    UpperCAmelCase_     :       Optional[Any]  		=					word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)    )
        UpperCAmelCase_     :       Dict  		=					char
    return pairs







class       _snake_case				(     __snake_case ):






   '''simple docstring'''






   A__      : str       =						VOCAB_FILES_NAMES
   A__      : Optional[int]       =						PRETRAINED_VOCAB_FILES_MAP
   A__      : str       =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   A__      : Tuple       =						["input_ids", "attention_mask"]


   def __init__(    self:     Union[str, Any]  ,lowerCamelCase_:     Any  ,lowerCamelCase_:     List[str]  ,lowerCamelCase_:     str="replace"  ,lowerCamelCase_:     Optional[int]="<s>"  ,lowerCamelCase_:     Optional[int]="</s>"  ,lowerCamelCase_:     Any="</s>"  ,lowerCamelCase_:     Union[str, Any]="<s>"  ,lowerCamelCase_:     List[str]="<unk>"  ,lowerCamelCase_:     Union[str, Any]="<pad>"  ,lowerCamelCase_:     int="<mask>"  ,lowerCamelCase_:     List[Any]=False  ,**lowerCamelCase_:     List[Any]  ,)	->      int:
       UpperCAmelCase_     :       Optional[Any]  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else bos_token
       UpperCAmelCase_     :       List[Any]  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else eos_token
       UpperCAmelCase_     :       int  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else sep_token
       UpperCAmelCase_     :       Dict  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else cls_token
       UpperCAmelCase_     :       Union[str, Any]  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else unk_token
       UpperCAmelCase_     :       Optional[int]  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else pad_token

       # Mask token behave like a normal word, i.e. include the space before it
       UpperCAmelCase_     :       Union[str, Any]  		=					AddedToken(lowerCamelCase_  ,lstrip=lowerCamelCase_  ,rstrip=lowerCamelCase_							) if isinstance(lowerCamelCase_  ,lowerCamelCase_							) else mask_token

       super().__init__(
           errors=lowerCamelCase_  ,bos_token=lowerCamelCase_  ,eos_token=lowerCamelCase_  ,unk_token=lowerCamelCase_  ,sep_token=lowerCamelCase_  ,cls_token=lowerCamelCase_  ,pad_token=lowerCamelCase_  ,mask_token=lowerCamelCase_  ,add_prefix_space=lowerCamelCase_  ,**lowerCamelCase_  ,)
       with open(lowerCamelCase_  ,encoding="""utf-8"""							) as vocab_handle:
           UpperCAmelCase_     :       Optional[int]  		=					json.load(lowerCamelCase_							)
       UpperCAmelCase_     :       List[Any]  		=					{v: k for k, v in self.encoder.items()}
       UpperCAmelCase_     :       str  		=					errors  # how to handle errors in decoding
       UpperCAmelCase_     :       Optional[Any]  		=					bytes_to_unicode()
       UpperCAmelCase_     :       str  		=					{v: k for k, v in self.byte_encoder.items()}
       with open(lowerCamelCase_  ,encoding="""utf-8"""							) as merges_handle:
           UpperCAmelCase_     :       int  		=					merges_handle.read().split("""\n"""							)[1:-1]
       UpperCAmelCase_     :       Optional[int]  		=					[tuple(merge.split()							) for merge in bpe_merges]
       UpperCAmelCase_     :       Dict  		=					dict(zip(lowerCamelCase_  ,range(len(lowerCamelCase_							)							)							)							)
       UpperCAmelCase_     :       Any  		=					{}
       UpperCAmelCase_     :       int  		=					add_prefix_space

       # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
       UpperCAmelCase_     :       Union[str, Any]  		=					re.compile(R"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""							)


   @property
   def       A__    (    self:     int							)	->      Dict:
       return len(self.encoder							)


   def       A__    (    self:     List[str]							)	->      Any:
       return dict(self.encoder  ,**self.added_tokens_encoder							)


   def       A__    (    self:     int  ,lowerCamelCase_:     Optional[Any]							)	->      Union[str, Any]:
       if token in self.cache:
           return self.cache[token]
       UpperCAmelCase_     :       Optional[Any]  		=					tuple(lowerCamelCase_							)
       UpperCAmelCase_     :       List[Any]  		=					get_pairs(lowerCamelCase_							)

       if not pairs:
           return token

       while True:
           UpperCAmelCase_     :       Dict  		=					min(lowerCamelCase_  ,key=lambda lowerCamelCase_							: self.bpe_ranks.get(lowerCamelCase_  ,float("""inf"""							)							)							)
           if bigram not in self.bpe_ranks:
               break
           UpperCAmelCase_		, UpperCAmelCase_     :       str  		=					bigram
           UpperCAmelCase_     :       List[str]  		=					[]
           UpperCAmelCase_     :       Union[str, Any]  		=					0
           while i < len(lowerCamelCase_							):
               try:
                   UpperCAmelCase_     :       List[Any]  		=					word.index(lowerCamelCase_  ,lowerCamelCase_							)
               except ValueError:
                   new_word.extend(word[i:]							)
                   break
               else:
                   new_word.extend(word[i:j]							)
                   UpperCAmelCase_     :       Union[str, Any]  		=					j

               if word[i] == first and i < len(lowerCamelCase_							) - 1 and word[i + 1] == second:
                   new_word.append(first + second							)
                   i += 2
               else:
                   new_word.append(word[i]							)
                   i += 1
           UpperCAmelCase_     :       str  		=					tuple(lowerCamelCase_							)
           UpperCAmelCase_     :       str  		=					new_word
           if len(lowerCamelCase_							) == 1:
               break
           else:
               UpperCAmelCase_     :       int  		=					get_pairs(lowerCamelCase_							)
       UpperCAmelCase_     :       List[str]  		=					""" """.join(lowerCamelCase_							)
       UpperCAmelCase_     :       str  		=					word
       return word


   def       A__    (    self:     Optional[Any]  ,lowerCamelCase_:     Union[str, Any]							)	->      int:
       UpperCAmelCase_     :       Optional[Any]  		=					[]
       for token in re.findall(self.pat  ,lowerCamelCase_							):
           UpperCAmelCase_     :       int  		=					"""""".join(
               self.byte_encoder[b] for b in token.encode("""utf-8"""							)							)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
           bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCamelCase_							).split(""" """							)							)
       return bpe_tokens


   def       A__    (    self:     Tuple  ,lowerCamelCase_:     List[str]							)	->      List[str]:
       return self.encoder.get(lowerCamelCase_  ,self.encoder.get(self.unk_token							)							)


   def       A__    (    self:     Any  ,lowerCamelCase_:     Optional[Any]							)	->      Optional[Any]:
       return self.decoder.get(lowerCamelCase_							)


   def       A__    (    self:     List[Any]  ,lowerCamelCase_:     Any							)	->      Union[str, Any]:
       UpperCAmelCase_     :       Union[str, Any]  		=					"""""".join(lowerCamelCase_							)
       UpperCAmelCase_     :       List[Any]  		=					bytearray([self.byte_decoder[c] for c in text]							).decode("""utf-8"""  ,errors=self.errors							)
       return text


   def       A__    (    self:     Union[str, Any]  ,lowerCamelCase_:     str  ,lowerCamelCase_:     Optional[str] = None							)	->      Tuple[str]:
       if not os.path.isdir(lowerCamelCase_							):
           logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''							)
           return
       UpperCAmelCase_     :       List[str]  		=					os.path.join(
           lowerCamelCase_  ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]							)
       UpperCAmelCase_     :       List[Any]  		=					os.path.join(
           lowerCamelCase_  ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]							)

       with open(lowerCamelCase_  ,"""w"""  ,encoding="""utf-8"""							) as f:
           f.write(json.dumps(self.encoder  ,indent=2  ,sort_keys=lowerCamelCase_  ,ensure_ascii=lowerCamelCase_							) + """\n"""							)

       UpperCAmelCase_     :       str  		=					0
       with open(lowerCamelCase_  ,"""w"""  ,encoding="""utf-8"""							) as writer:
           writer.write("""#version: 0.2\n"""							)
           for bpe_tokens, token_index in sorted(self.bpe_ranks.items()  ,key=lambda lowerCamelCase_							: kv[1]							):
               if index != token_index:
                   logger.warning(
                       F'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
                       """ Please check that the tokenizer is not corrupted!"""							)
                   UpperCAmelCase_     :       List[str]  		=					token_index
               writer.write(""" """.join(lowerCamelCase_							) + """\n"""							)
               index += 1

       return vocab_file, merge_file


   def       A__    (    self:     Any  ,lowerCamelCase_:     List[int]  ,lowerCamelCase_:     Optional[List[int]] = None							)	->      List[int]:
       if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
       UpperCAmelCase_     :       Tuple  		=					[self.cls_token_id]
       UpperCAmelCase_     :       str  		=					[self.sep_token_id]
       return cls + token_ids_a + sep + sep + token_ids_a + sep


   def       A__    (    self:     int  ,lowerCamelCase_:     List[int]  ,lowerCamelCase_:     Optional[List[int]] = None  ,lowerCamelCase_:     bool = False							)	->      List[int]:
       if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=lowerCamelCase_  ,token_ids_a=lowerCamelCase_  ,already_has_special_tokens=lowerCamelCase_							)

       if token_ids_a is None:
           return [1] + ([0] * len(lowerCamelCase_							)) + [1]
       return [1] + ([0] * len(lowerCamelCase_							)) + [1, 1] + ([0] * len(lowerCamelCase_							)) + [1]


   def       A__    (    self:     Optional[Any]  ,lowerCamelCase_:     List[int]  ,lowerCamelCase_:     Optional[List[int]] = None							)	->      List[int]:
       UpperCAmelCase_     :       List[Any]  		=					[self.sep_token_id]
       UpperCAmelCase_     :       int  		=					[self.cls_token_id]

       if token_ids_a is None:
           return len(cls + token_ids_a + sep							) * [0]
       return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]






   def       A__    (    self:     Tuple  ,lowerCamelCase_:     str  ,lowerCamelCase_:     Tuple=False  ,**lowerCamelCase_:     List[Any]							)	->      Any:
       UpperCAmelCase_     :       List[str]  		=					kwargs.pop("""add_prefix_space"""  ,self.add_prefix_space							)
       if (is_split_into_words or add_prefix_space) and (len(lowerCamelCase_							) > 0 and not text[0].isspace()):
           UpperCAmelCase_     :       List[str]  		=					""" """ + text
       return (text, kwargs)


import inspect
import unittest

import requests

from transformers import MgpstrConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
				from PIL import Image

				from transformers import MgpstrProcessor






class 							SCREAMING_SNAKE_CASE__     :

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=False  ,						SCREAMING_SNAKE_CASE_=13  ,						SCREAMING_SNAKE_CASE_=(32, 128)  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=27  ,						SCREAMING_SNAKE_CASE_=38  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=32  ,						SCREAMING_SNAKE_CASE_=5  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=4.0  ,						SCREAMING_SNAKE_CASE_=257  ,						SCREAMING_SNAKE_CASE_=None  ,						)-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      parent
													__UpperCamelCase  	=      is_training
													__UpperCamelCase  	=      batch_size
													__UpperCamelCase  	=      image_size
													__UpperCamelCase  	=      patch_size
													__UpperCamelCase  	=      num_channels
													__UpperCamelCase  	=      max_token_length
													__UpperCamelCase  	=      num_character_labels
													__UpperCamelCase  	=      num_bpe_labels
													__UpperCamelCase  	=      num_wordpiece_labels
													__UpperCamelCase  	=      hidden_size
													__UpperCamelCase  	=      num_hidden_layers
													__UpperCamelCase  	=      num_attention_heads
													__UpperCamelCase  	=      mlp_ratio
													__UpperCamelCase  	=      patch_embeds_hidden_size
													__UpperCamelCase  	=      output_hidden_states



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]      )
													__UpperCamelCase  	=      self.get_config()
													return config, pixel_values



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													return MgpstrConfig(
													    image_size=self.image_size  ,						patch_size=self.patch_size  ,						num_channels=self.num_channels  ,						max_token_length=self.max_token_length  ,						num_character_labels=self.num_character_labels  ,						num_bpe_labels=self.num_bpe_labels  ,						num_wordpiece_labels=self.num_wordpiece_labels  ,						hidden_size=self.hidden_size  ,						num_hidden_layers=self.num_hidden_layers  ,						num_attention_heads=self.num_attention_heads  ,						mlp_ratio=self.mlp_ratio  ,						output_hidden_states=self.output_hidden_states  ,						)



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrForSceneTextRecognition(SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )
													self.parent.assertEqual(
													    generated_ids[0][0].shape  ,						(self.batch_size, self.max_token_length, self.num_character_labels)      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.prepare_config_and_inputs()
													__UpperCamelCase	,				__UpperCamelCase  	=      config_and_inputs
													__UpperCamelCase  	=      {'''pixel_values''': pixel_values}
													return config, inputs_dict






@require_torch
class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_ ,		SCREAMING_SNAKE_CASE_ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
							_snake_case  		=	{'feature-extraction': MgpstrForSceneTextRecognition} if is_torch_available() else {}
							_snake_case  		=	False

							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrModelTester(self      )
													__UpperCamelCase  	=      ConfigTester(self  ,						config_class=SCREAMING_SNAKE_CASE_  ,						has_text_modality=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Any:





													'''simple docstring'''






													self.config_tester.run_common_tests()



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not use inputs_embeds'''      )
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertIsInstance(model.get_input_embeddings()  ,						(nn.Module)      )
																			__UpperCamelCase  	=      model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_  ,						nn.Linear      )      )



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			__UpperCamelCase  	=      inspect.signature(model.forward      )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			__UpperCamelCase  	=      [*signature.parameters.keys()]

																			__UpperCamelCase  	=      ['''pixel_values''']
																			self.assertListEqual(arg_names[:1]  ,						SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not support feedforward chunking'''      )
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			if not model_class.supports_gradient_checkpointing:
																									continue

																			__UpperCamelCase  	=      True
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertTrue(model.is_gradient_checkpointing      )



							def      A__		(	self      )-> str:





													'''simple docstring'''






													def check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      ):
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			model.to(SCREAMING_SNAKE_CASE_      )
																			model.eval()

																			with torch.no_grad():
																									__UpperCamelCase  	=      model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )      )

																			__UpperCamelCase  	=      outputs.hidden_states

																			__UpperCamelCase  	=      getattr(
																			    self.model_tester  ,						'''expected_num_hidden_layers'''  ,						self.model_tester.num_hidden_layers + 1      )
																			self.assertEqual(len(SCREAMING_SNAKE_CASE_      )  ,						SCREAMING_SNAKE_CASE_      )

																			self.assertListEqual(
																			    list(hidden_states[0].shape[-2:]      )  ,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]  ,						)

													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      True
																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			__UpperCamelCase  	=      True

																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase  	=      _config_zero_init(SCREAMING_SNAKE_CASE_      )
													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(config=SCREAMING_SNAKE_CASE_      )
																			for name, param in model.named_parameters():
																									if isinstance(SCREAMING_SNAKE_CASE_  ,						(nn.Linear, nn.Convad, nn.LayerNorm)      ):
																															if param.requires_grad:
																																					self.assertIn(
																																					    ((param.data.mean() * 1E9).round() / 1E9).item()  ,						[0.0, 1.0]  ,						msg=F"Parameter {name} of model {model_class} seems not properly initialized"  ,						)



							@unittest.skip(reason='''Retain_grad is tested in individual model tests'''      )
							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													pass





def 						A_			(				)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase  	=      '''https://i.postimg.cc/ZKwLg2Gw/367-14.png'''
						__UpperCamelCase  	=      Image.open(requests.get(snake_case			,   stream=snake_case			).raw			).convert('''RGB'''			)
						return im






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

							"""simple docstring"""






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





													'''simple docstring'''






													__UpperCamelCase  	=      '''alibaba-damo/mgp-str-base'''
													__UpperCamelCase  	=      MgpstrForSceneTextRecognition.from_pretrained(SCREAMING_SNAKE_CASE_      ).to(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      MgpstrProcessor.from_pretrained(SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      prepare_img()
													__UpperCamelCase  	=      processor(images=SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values.to(SCREAMING_SNAKE_CASE_      )

													# forward pass
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )

													# verify the logits
													self.assertEqual(outputs.logits[0].shape  ,						torch.Size((1, 27, 38)      )      )

													__UpperCamelCase  	=      processor.batch_decode(outputs.logits      )
													__UpperCamelCase  	=      '''ticket'''

													self.assertEqual(out_strs['''generated_text'''][0]  ,						SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      torch.tensor(
													    [[[-3_9.5_3_9_7, -4_4.4_0_2_4, -3_6.1_8_4_4], [-6_1.4_7_0_9, -6_3.8_6_3_9, -5_8.3_4_5_4], [-7_4.0_2_2_5, -6_8.5_4_9_4, -7_1.2_1_6_4]]]  ,						device=SCREAMING_SNAKE_CASE_  ,						)

													self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]  ,						SCREAMING_SNAKE_CASE_  ,						atol=1E-4      )      )




