

import json
import os
import re
import unicodedata
from typing import Dict, List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


_SCREAMING_SNAKE_CASE							 =			logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE							 =			{
    '''src_vocab_file''': '''vocab-src.json''',
    '''tgt_vocab_file''': '''vocab-tgt.json''',
    '''merges_file''': '''merges.txt''',
}

_SCREAMING_SNAKE_CASE							 =			{
    '''src_vocab_file''': {
        '''stas/tiny-wmt19-en-de''': '''https://huggingface.co/stas/tiny-wmt19-en-de/resolve/main/vocab-src.json'''
    },
    '''tgt_vocab_file''': {
        '''stas/tiny-wmt19-en-de''': '''https://huggingface.co/stas/tiny-wmt19-en-de/resolve/main/vocab-tgt.json'''
    },
    '''merges_file''': {'''stas/tiny-wmt19-en-de''': '''https://huggingface.co/stas/tiny-wmt19-en-de/resolve/main/merges.txt'''},
}

_SCREAMING_SNAKE_CASE							 =			{'''stas/tiny-wmt19-en-de''': 1_0_2_4}
_SCREAMING_SNAKE_CASE							 =			{
    '''stas/tiny-wmt19-en-de''': {
        '''langs''': ['''en''', '''de'''],
        '''model_max_length''': 1_0_2_4,
        '''special_tokens_map_file''': None,
        '''full_tokenizer_file''': None,
    }
}





def  _snake_case		(snake_case_					:     Optional[Any]  )							->		Any:
  __UpperCAmelCase	:  Optional[int]		=     set()
  __UpperCAmelCase	:  Any		=     word[0]
  for char in word[1:]:
    pairs.add((prev_char, char)  )
    __UpperCAmelCase	:  Optional[Any]		=     char
  return pairs





def  _snake_case		(snake_case_					:     List[Any]  )							->		Optional[int]:
  __UpperCAmelCase	:  Any		=     text.replace('，'    ,       ','  )
  __UpperCAmelCase	:  Optional[Any]		=     re.sub(R'。\s*'    ,       '. '    ,       snake_case_  )
  __UpperCAmelCase	:  str		=     text.replace('、'    ,       ','  )
  __UpperCAmelCase	:  int		=     text.replace('”'    ,       '"'  )
  __UpperCAmelCase	:  List[Any]		=     text.replace('“'    ,       '"'  )
  __UpperCAmelCase	:  Optional[int]		=     text.replace('∶'    ,       ':'  )
  __UpperCAmelCase	:  Dict		=     text.replace('：'    ,       ':'  )
  __UpperCAmelCase	:  Tuple		=     text.replace('？'    ,       '?'  )
  __UpperCAmelCase	:  Union[str, Any]		=     text.replace('《'    ,       '"'  )
  __UpperCAmelCase	:  Optional[Any]		=     text.replace('》'    ,       '"'  )
  __UpperCAmelCase	:  int		=     text.replace('）'    ,       ')'  )
  __UpperCAmelCase	:  Union[str, Any]		=     text.replace('！'    ,       '!'  )
  __UpperCAmelCase	:  Optional[int]		=     text.replace('（'    ,       '('  )
  __UpperCAmelCase	:  Union[str, Any]		=     text.replace('；'    ,       ';'  )
  __UpperCAmelCase	:  List[Any]		=     text.replace('１'    ,       '1'  )
  __UpperCAmelCase	:  List[str]		=     text.replace('」'    ,       '"'  )
  __UpperCAmelCase	:  Optional[int]		=     text.replace('「'    ,       '"'  )
  __UpperCAmelCase	:  Optional[Any]		=     text.replace('０'    ,       '0'  )
  __UpperCAmelCase	:  Optional[int]		=     text.replace('３'    ,       '3'  )
  __UpperCAmelCase	:  Dict		=     text.replace('２'    ,       '2'  )
  __UpperCAmelCase	:  Any		=     text.replace('５'    ,       '5'  )
  __UpperCAmelCase	:  List[Any]		=     text.replace('６'    ,       '6'  )
  __UpperCAmelCase	:  Any		=     text.replace('９'    ,       '9'  )
  __UpperCAmelCase	:  Any		=     text.replace('７'    ,       '7'  )
  __UpperCAmelCase	:  Optional[int]		=     text.replace('８'    ,       '8'  )
  __UpperCAmelCase	:  Any		=     text.replace('４'    ,       '4'  )
  __UpperCAmelCase	:  List[str]		=     re.sub(R'．\s*'    ,       '. '    ,       snake_case_  )
  __UpperCAmelCase	:  Any		=     text.replace('～'    ,       '~'  )
  __UpperCAmelCase	:  Dict		=     text.replace('’'    ,       '\''  )
  __UpperCAmelCase	:  Dict		=     text.replace('…'    ,       '...'  )
  __UpperCAmelCase	:  Dict		=     text.replace('━'    ,       '-'  )
  __UpperCAmelCase	:  List[Any]		=     text.replace('〈'    ,       '<'  )
  __UpperCAmelCase	:  Dict		=     text.replace('〉'    ,       '>'  )
  __UpperCAmelCase	:  Tuple		=     text.replace('【'    ,       '['  )
  __UpperCAmelCase	:  List[Any]		=     text.replace('】'    ,       ']'  )
  __UpperCAmelCase	:  int		=     text.replace('％'    ,       '%'  )
  return text





def  _snake_case		(snake_case_					:     List[str]  )							->		Dict:
  __UpperCAmelCase	:  Any		=     []
  for char in text:
    __UpperCAmelCase	:  List[Any]		=     unicodedata.category(snake_case_  )
    if cat.startswith('C'  ):
      continue
    output.append(snake_case_  )
  return "".join(snake_case_  )







class      lowerCamelCase_ (			_lowerCAmelCase):
 _lowerCAmelCase									=	VOCAB_FILES_NAMES
 _lowerCAmelCase									=	PRETRAINED_VOCAB_FILES_MAP
 _lowerCAmelCase									=	PRETRAINED_INIT_CONFIGURATION
 _lowerCAmelCase									=	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 _lowerCAmelCase									=	['''input_ids''', '''attention_mask''']




 def __init__(			self  ,  _UpperCAmelCase=None  ,  _UpperCAmelCase=None  ,  _UpperCAmelCase=None  ,  _UpperCAmelCase=None  ,  _UpperCAmelCase=False  ,  _UpperCAmelCase="<unk>"  ,  _UpperCAmelCase="<s>"  ,  _UpperCAmelCase="</s>"  ,  _UpperCAmelCase="<pad>"  ,  **_UpperCAmelCase  ,  ):
   super().__init__(
       langs=_UpperCAmelCase  ,  src_vocab_file=_UpperCAmelCase  ,  tgt_vocab_file=_UpperCAmelCase  ,  merges_file=_UpperCAmelCase  ,  do_lower_case=_UpperCAmelCase  ,  unk_token=_UpperCAmelCase  ,  bos_token=_UpperCAmelCase  ,  sep_token=_UpperCAmelCase  ,  pad_token=_UpperCAmelCase  ,  **_UpperCAmelCase  ,  )

   try:
     import sacremoses
   except ImportError:
     raise ImportError(
         'You need to install sacremoses to use XLMTokenizer. '
         'See https://pypi.org/project/sacremoses/ for installation.'							)

   __UpperCAmelCase	:  int		=     sacremoses

   __UpperCAmelCase	:  Tuple		=     src_vocab_file
   __UpperCAmelCase	:  List[Any]		=     tgt_vocab_file
   __UpperCAmelCase	:  List[Any]		=     merges_file
   __UpperCAmelCase	:  List[str]		=     do_lower_case

   # cache of sm.MosesPunctNormalizer instance
   __UpperCAmelCase	:  Optional[int]		=     {}
   # cache of sm.MosesTokenizer instance
   __UpperCAmelCase	:  int		=     {}
   __UpperCAmelCase	:  int		=     {}

   if langs and len(_UpperCAmelCase							) == 2:
     __UpperCAmelCase,			__UpperCAmelCase	:  Optional[Any]		=     langs
   else:
     raise ValueError(
         F"arg `langs` needs to be a list of 2 langs, e.g. ['en', 'ru'], but got {langs}. "
         'Usually that means that tokenizer can\'t find a mapping for the given model path '
         'in PRETRAINED_VOCAB_FILES_MAP, and other maps of this tokenizer.'							)

   with open(_UpperCAmelCase  ,  encoding='utf-8'							) as src_vocab_handle:
     __UpperCAmelCase	:  Union[str, Any]		=     json.load(_UpperCAmelCase							)
   with open(_UpperCAmelCase  ,  encoding='utf-8'							) as tgt_vocab_handle:
     __UpperCAmelCase	:  int		=     json.load(_UpperCAmelCase							)
     __UpperCAmelCase	:  Dict		=     {v: k for k, v in tgt_vocab.items()}
   with open(_UpperCAmelCase  ,  encoding='utf-8'							) as merges_handle:
     __UpperCAmelCase	:  int		=     merges_handle.read().split('\n'							)[:-1]
   __UpperCAmelCase	:  Any		=     [tuple(merge.split()[:2]							) for merge in merges]
   __UpperCAmelCase	:  List[str]		=     dict(zip(_UpperCAmelCase  ,  range(len(_UpperCAmelCase							)							)							)							)
   __UpperCAmelCase	:  List[str]		=     {}




 def     a       (			self							):
   return self.get_src_vocab()




 @property
 def     a       (			self							):
   return self.src_vocab_size




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase							):
   if lang not in self.cache_moses_punct_normalizer:
     __UpperCAmelCase	:  Union[str, Any]		=     self.sm.MosesPunctNormalizer(lang=_UpperCAmelCase							)
     __UpperCAmelCase	:  str		=     punct_normalizer
   return self.cache_moses_punct_normalizer[lang].normalize(_UpperCAmelCase							)




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase							):
   if lang not in self.cache_moses_tokenizer:
     __UpperCAmelCase	:  int		=     self.sm.MosesTokenizer(lang=_UpperCAmelCase							)
     __UpperCAmelCase	:  str		=     moses_tokenizer
   return self.cache_moses_tokenizer[lang].tokenize(
       _UpperCAmelCase  ,  aggressive_dash_splits=_UpperCAmelCase  ,  return_str=_UpperCAmelCase  ,  escape=_UpperCAmelCase							)




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase							):
   if lang not in self.cache_moses_detokenizer:
     __UpperCAmelCase	:  Union[str, Any]		=     self.sm.MosesDetokenizer(lang=_UpperCAmelCase							)
     __UpperCAmelCase	:  Tuple		=     moses_detokenizer
   return self.cache_moses_detokenizer[lang].detokenize(_UpperCAmelCase							)




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase							):
   __UpperCAmelCase	:  int		=     replace_unicode_punct(_UpperCAmelCase							)
   __UpperCAmelCase	:  Optional[Any]		=     self.moses_punct_norm(_UpperCAmelCase  ,  _UpperCAmelCase							)
   __UpperCAmelCase	:  List[str]		=     remove_non_printing_char(_UpperCAmelCase							)
   return text




 @property
 def     a       (			self							):
   return len(self.encoder							)




 @property
 def     a       (			self							):
   return len(self.decoder							)




 def     a       (			self							):
   return dict(self.encoder  ,  **self.added_tokens_encoder							)




 def     a       (			self							):
   return dict(self.decoder  ,  **self.added_tokens_decoder							)




 def     a       (			self  ,  _UpperCAmelCase							):
   __UpperCAmelCase	:  int		=     tuple(token[:-1]							) + (token[-1] + '</w>',)
   if token in self.cache:
     return self.cache[token]
   __UpperCAmelCase	:  Union[str, Any]		=     get_pairs(_UpperCAmelCase							)

   if not pairs:
     return token + "</w>"

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

       if word[i] == first and i < len(_UpperCAmelCase							) - 1 and word[i + 1] == second:
         new_word.append(first + second							)
         i += 2
       else:
         new_word.append(word[i]							)
         i += 1
     __UpperCAmelCase	:  Optional[Any]		=     tuple(_UpperCAmelCase							)
     __UpperCAmelCase	:  str		=     new_word
     if len(_UpperCAmelCase							) == 1:
       break
     else:
       __UpperCAmelCase	:  str		=     get_pairs(_UpperCAmelCase							)
   __UpperCAmelCase	:  Optional[Any]		=     ' '.join(_UpperCAmelCase							)
   if word == "\n  </w>":
     __UpperCAmelCase	:  Tuple		=     '\n</w>'
   __UpperCAmelCase	:  str		=     word
   return word




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase="en"  ,  _UpperCAmelCase=False							):
   __UpperCAmelCase	:  Union[str, Any]		=     self.src_lang

   if self.do_lower_case:
     __UpperCAmelCase	:  List[Any]		=     text.lower()

   if bypass_tokenizer:
     __UpperCAmelCase	:  List[str]		=     text.split()
   else:
     __UpperCAmelCase	:  List[Any]		=     self.moses_pipeline(_UpperCAmelCase  ,  lang=_UpperCAmelCase							)
     __UpperCAmelCase	:  Union[str, Any]		=     self.moses_tokenize(_UpperCAmelCase  ,  lang=_UpperCAmelCase							)

   __UpperCAmelCase	:  Dict		=     []
   for token in text:
     if token:
       split_tokens.extend(list(self.bpe(_UpperCAmelCase							).split(' '							)							)							)

   return split_tokens




 def     a       (			self  ,  _UpperCAmelCase							):
   return self.encoder.get(_UpperCAmelCase  ,  self.encoder.get(self.unk_token							)							)




 def     a       (			self  ,  _UpperCAmelCase							):
   return self.decoder.get(_UpperCAmelCase  ,  self.unk_token							)




 def     a       (			self  ,  _UpperCAmelCase							):
   __UpperCAmelCase	:  str		=     [t.replace(' '  ,  ''							).replace('</w>'  ,  ' '							) for t in tokens]
   __UpperCAmelCase	:  Dict		=     ''.join(_UpperCAmelCase							).split()
   # detokenize
   __UpperCAmelCase	:  Union[str, Any]		=     self.moses_detokenize(_UpperCAmelCase  ,  self.tgt_lang							)
   return text




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase = None							):
   __UpperCAmelCase	:  List[Any]		=     [self.sep_token_id]

   # no bos used in fairseq
   if token_ids_a is None:
     return token_ids_a + sep
   return token_ids_a + sep + token_ids_a + sep




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase = None  ,  _UpperCAmelCase = False							):

   if already_has_special_tokens:
     return super().get_special_tokens_mask(
         token_ids_a=_UpperCAmelCase  ,  token_ids_a=_UpperCAmelCase  ,  already_has_special_tokens=_UpperCAmelCase							)
   # no bos used in fairseq
   if token_ids_a is not None:
     return ([0] * len(_UpperCAmelCase							)) + [1] + ([0] * len(_UpperCAmelCase							)) + [1]
   return ([0] * len(_UpperCAmelCase							)) + [1]




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase = None							):
   __UpperCAmelCase	:  Any		=     [self.sep_token_id]

   # no bos used in fairseq
   if token_ids_a is None:
     return len(token_ids_a + sep							) * [0]
   return len(token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]




 def     a       (			self  ,  _UpperCAmelCase  ,  _UpperCAmelCase = None							):
   if not os.path.isdir(_UpperCAmelCase							):
     logger.error(F"Vocabulary path ({save_directory}) should be a directory"							)
     return

   __UpperCAmelCase	:  Tuple		=     os.path.join(
       _UpperCAmelCase  ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['src_vocab_file']							)
   __UpperCAmelCase	:  List[Any]		=     os.path.join(
       _UpperCAmelCase  ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['tgt_vocab_file']							)
   __UpperCAmelCase	:  int		=     os.path.join(
       _UpperCAmelCase  ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']							)

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

   with open(_UpperCAmelCase  ,  'w'  ,  encoding='utf-8'							) as f:
     __UpperCAmelCase	:  Optional[Any]		=     {v: k for k, v in self.decoder.items()}
     f.write(json.dumps(_UpperCAmelCase  ,  indent=2  ,  sort_keys=_UpperCAmelCase  ,  ensure_ascii=_UpperCAmelCase							) + '\n'							)

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

   return src_vocab_file, tgt_vocab_file, merges_file




 def __getstate__(			self							):
   __UpperCAmelCase	:  Dict		=     self.__dict__.copy()
   __UpperCAmelCase	:  int		=     None
   return state




 def __setstate__(			self  ,  _UpperCAmelCase							):
   __UpperCAmelCase	:  Tuple		=     d

   try:
     import sacremoses
   except ImportError:
     raise ImportError(
         'You need to install sacremoses to use XLMTokenizer. '
         'See https://pypi.org/project/sacremoses/ for installation.'							)

   __UpperCAmelCase	:  Dict		=     sacremoses







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      )      )




