


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

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


_UpperCAmelCase     :					Any       =logging.get_logger(__name__)

_UpperCAmelCase     :					Tuple       ={
    """src_vocab_file""": """vocab-src.json""",
    """tgt_vocab_file""": """vocab-tgt.json""",
    """merges_file""": """merges.txt""",
}

_UpperCAmelCase     :					List[str]       ={
    """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"""},
}

_UpperCAmelCase     :					Optional[Any]       ={"""stas/tiny-wmt19-en-de""": 1024}
_UpperCAmelCase     :					Tuple       ={
    """stas/tiny-wmt19-en-de""": {
        """langs""": ["""en""", """de"""],
        """model_max_length""": 1024,
        """special_tokens_map_file""": None,
        """full_tokenizer_file""": None,
    }
}



def      lowerCAmelCase	(						lowerCAmelCase_	)->	Dict:
				lowerCAmelCase_	: Union[str, Any]      			=			set()
				lowerCAmelCase_	: Optional[Any]      			=			word[0]
				for char in word[1:]:
								pairs.add((prev_char, char)	)
								lowerCAmelCase_	: Union[str, Any]      			=			char
				return pairs



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



def      lowerCAmelCase	(						lowerCAmelCase_	)->	Union[str, Any]:
				lowerCAmelCase_	: Optional[int]      			=			[]
				for char in text:
								lowerCAmelCase_	: Tuple      			=			unicodedata.category(lowerCAmelCase_	)
								if cat.startswith('''C'''	):
												continue
								output.append(lowerCAmelCase_	)
				return "".join(lowerCAmelCase_	)







class 			snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							VOCAB_FILES_NAMES
						SCREAMING_SNAKE_CASE__ :					Tuple   =							PRETRAINED_VOCAB_FILES_MAP
						SCREAMING_SNAKE_CASE__ :					str   =							PRETRAINED_INIT_CONFIGURATION
						SCREAMING_SNAKE_CASE__ :					str   =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						SCREAMING_SNAKE_CASE__ :					int   =							["""input_ids""", """attention_mask"""]




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

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

										lowerCAmelCase_	: Optional[int]      			=			sacremoses

										lowerCAmelCase_	: Union[str, Any]      			=			src_vocab_file
										lowerCAmelCase_	: List[Any]      			=			tgt_vocab_file
										lowerCAmelCase_	: List[Any]      			=			merges_file
										lowerCAmelCase_	: Optional[Any]      			=			do_lower_case

										# cache of sm.MosesPunctNormalizer instance
										lowerCAmelCase_	: str      			=			{}
										# cache of sm.MosesTokenizer instance
										lowerCAmelCase_	: Optional[Any]      			=			{}
										lowerCAmelCase_	: str      			=			{}

										if langs and len(__lowercase							) == 2:
														lowerCAmelCase_			,					lowerCAmelCase_	: Tuple      			=			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(__lowercase				,  encoding='''utf-8'''							) as src_vocab_handle:
														lowerCAmelCase_	: List[Any]      			=			json.load(__lowercase							)
										with open(__lowercase				,  encoding='''utf-8'''							) as tgt_vocab_handle:
														lowerCAmelCase_	: List[str]      			=			json.load(__lowercase							)
														lowerCAmelCase_	: Optional[Any]      			=			{v: k for k, v in tgt_vocab.items()}
										with open(__lowercase				,  encoding='''utf-8'''							) as merges_handle:
														lowerCAmelCase_	: int      			=			merges_handle.read().split('''\n'''							)[:-1]
										lowerCAmelCase_	: Tuple      			=			[tuple(merge.split()[:2]							) for merge in merges]
										lowerCAmelCase_	: Union[str, Any]      			=			dict(zip(__lowercase				,  range(len(__lowercase							)							)							)							)
										lowerCAmelCase_	: Dict      			=			{}




						def   lowercase_	(			self							)   ->      Dict[str, int]:
										return self.get_src_vocab()




						@property
						def   lowercase_	(			self							)   ->      int:
										return self.src_vocab_size




						def   lowercase_	(			self				,  __lowercase				,  __lowercase							)   ->      Optional[int]:
										if lang not in self.cache_moses_punct_normalizer:
														lowerCAmelCase_	: str      			=			self.sm.MosesPunctNormalizer(lang=__lowercase							)
														lowerCAmelCase_	: Tuple      			=			punct_normalizer
										return self.cache_moses_punct_normalizer[lang].normalize(__lowercase							)




						def   lowercase_	(			self				,  __lowercase				,  __lowercase							)   ->      int:
										if lang not in self.cache_moses_tokenizer:
														lowerCAmelCase_	: Dict      			=			self.sm.MosesTokenizer(lang=__lowercase							)
														lowerCAmelCase_	: Any      			=			moses_tokenizer
										return self.cache_moses_tokenizer[lang].tokenize(
										    __lowercase				,  aggressive_dash_splits=__lowercase				,  return_str=__lowercase				,  escape=__lowercase							)




						def   lowercase_	(			self				,  __lowercase				,  __lowercase							)   ->      str:
										if lang not in self.cache_moses_detokenizer:
														lowerCAmelCase_	: int      			=			self.sm.MosesDetokenizer(lang=__lowercase							)
														lowerCAmelCase_	: Dict      			=			moses_detokenizer
										return self.cache_moses_detokenizer[lang].detokenize(__lowercase							)




						def   lowercase_	(			self				,  __lowercase				,  __lowercase							)   ->      List[Any]:
										lowerCAmelCase_	: str      			=			replace_unicode_punct(__lowercase							)
										lowerCAmelCase_	: Any      			=			self.moses_punct_norm(__lowercase				,  __lowercase							)
										lowerCAmelCase_	: List[str]      			=			remove_non_printing_char(__lowercase							)
										return text




						@property
						def   lowercase_	(			self							)   ->      str:
										return len(self.encoder							)




						@property
						def   lowercase_	(			self							)   ->      List[Any]:
										return len(self.decoder							)




						def   lowercase_	(			self							)   ->      Dict:
										return dict(self.encoder				,  **self.added_tokens_encoder							)




						def   lowercase_	(			self							)   ->      List[Any]:
										return dict(self.decoder				,  **self.added_tokens_decoder							)




						def   lowercase_	(			self				,  __lowercase							)   ->      Dict:
										lowerCAmelCase_	: Tuple      			=			tuple(token[:-1]							) + (token[-1] + '''</w>''',)
										if token in self.cache:
														return self.cache[token]
										lowerCAmelCase_	: str      			=			get_pairs(__lowercase							)

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

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

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




						def   lowercase_	(			self				,  __lowercase				,  __lowercase="en"				,  __lowercase=False							)   ->      Tuple:
										lowerCAmelCase_	: Optional[Any]      			=			self.src_lang

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

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

										lowerCAmelCase_	: int      			=			[]
										for token in text:
														if token:
																		split_tokens.extend(list(self.bpe(__lowercase							).split(''' '''							)							)							)

										return split_tokens




						def   lowercase_	(			self				,  __lowercase							)   ->      Optional[Any]:
										return self.encoder.get(__lowercase				,  self.encoder.get(self.unk_token							)							)




						def   lowercase_	(			self				,  __lowercase							)   ->      str:
										return self.decoder.get(__lowercase				,  self.unk_token							)




						def   lowercase_	(			self				,  __lowercase							)   ->      List[str]:
										lowerCAmelCase_	: Union[str, Any]      			=			[t.replace(''' '''				,  ''''''							).replace('''</w>'''				,  ''' '''							) for t in tokens]
										lowerCAmelCase_	: Optional[int]      			=			''''''.join(__lowercase							).split()
										# detokenize
										lowerCAmelCase_	: Tuple      			=			self.moses_detokenize(__lowercase				,  self.tgt_lang							)
										return text




						def   lowercase_	(			self				,  __lowercase				,  __lowercase = None							)   ->      List[int]:
										lowerCAmelCase_	: List[str]      			=			[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   lowercase_	(			self				,  __lowercase				,  __lowercase = None				,  __lowercase = False							)   ->      List[int]:

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




						def   lowercase_	(			self				,  __lowercase				,  __lowercase = None							)   ->      List[int]:
										lowerCAmelCase_	: Optional[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   lowercase_	(			self				,  __lowercase				,  __lowercase = None							)   ->      Tuple[str]:
										if not os.path.isdir(__lowercase							):
														logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""							)
														return

										lowerCAmelCase_	: int      			=			os.path.join(
										    __lowercase				,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''src_vocab_file''']							)
										lowerCAmelCase_	: Any      			=			os.path.join(
										    __lowercase				,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''tgt_vocab_file''']							)
										lowerCAmelCase_	: Optional[int]      			=			os.path.join(
										    __lowercase				,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']							)

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

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

										lowerCAmelCase_	: Union[str, Any]      			=			0
										with open(__lowercase				,  '''w'''				,  encoding='''utf-8'''							) as writer:
														for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,  key=lambda __lowercase							: 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!'''							)
																						lowerCAmelCase_	: Dict      			=			token_index
																		writer.write(''' '''.join(__lowercase							) + '''\n'''							)
																		index += 1

										return src_vocab_file, tgt_vocab_file, merges_file




						def __getstate__(			self							)   ->      int:
										lowerCAmelCase_	: int      			=			self.__dict__.copy()
										lowerCAmelCase_	: List[str]      			=			None
										return state




						def __setstate__(			self				,  __lowercase							)   ->      int:
										lowerCAmelCase_	: List[str]      			=			d

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

										lowerCAmelCase_	: int      			=			sacremoses



from ..utils import DummyObject, requires_backends







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)