





"""simple docstring"""
import inspect
import unittest

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

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
		from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor






class    _UpperCAmelCase  :


					def __init__(   self     :Optional[Any]	,			__UpperCamelCase     :Dict	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :Optional[int]=32	,			__UpperCamelCase     :str=3	,			__UpperCamelCase     :Union[str, Any]=10	,			__UpperCamelCase     :Union[str, Any]=[10, 20, 30, 40]	,			__UpperCamelCase     :int=[1, 1, 2, 1]	,			__UpperCamelCase     :Dict=True	,			__UpperCamelCase     :Optional[Any]=True	,			__UpperCamelCase     :Any="relu"	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :int=None	,			__UpperCamelCase     :str=["stage2", "stage3", "stage4"]	,			__UpperCamelCase     :str=[2, 3, 4]	,			):
												A						=    parent
												A						=    batch_size
												A						=    image_size
												A						=    num_channels
												A						=    embeddings_size
												A						=    hidden_sizes
												A						=    depths
												A						=    is_training
												A						=    use_labels
												A						=    hidden_act
												A						=    num_labels
												A						=    scope
												A						=    len(__UpperCamelCase						)
												A						=    out_features
												A						=    out_indices


					def       lowerCamelCase			(   self     :List[Any]						):
												A						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

												A						=    None
												if self.use_labels:
																			A						=    ids_tensor([self.batch_size]	,			self.num_labels						)

												A						=    self.get_config()

												return config, pixel_values, labels


					def       lowerCamelCase			(   self     :Optional[Any]						):
												return ResNetConfig(
												    num_channels=self.num_channels	,			embeddings_size=self.embeddings_size	,			hidden_sizes=self.hidden_sizes	,			depths=self.depths	,			hidden_act=self.hidden_act	,			num_labels=self.num_labels	,			out_features=self.out_features	,			out_indices=self.out_indices	,			)


					def       lowerCamelCase			(   self     :int	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :str	,			__UpperCamelCase     :List[Any]						):
												A						=    ResNetModel(config=__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												A						=    model(__UpperCamelCase						)
												# expected last hidden states: B, C, H // 32, W // 32
												self.parent.assertEqual(
												    result.last_hidden_state.shape	,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)	,			)


					def       lowerCamelCase			(   self     :int	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :str	,			__UpperCamelCase     :str						):
												A						=    self.num_labels
												A						=    ResNetForImageClassification(__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												A						=    model(__UpperCamelCase	,			labels=__UpperCamelCase						)
												self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.num_labels)						)


					def       lowerCamelCase			(   self     :Dict	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :str						):
												A						=    ResNetBackbone(config=__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												A						=    model(__UpperCamelCase						)

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps						)	,			len(config.out_features						)						)
												self.parent.assertListEqual(list(result.feature_maps[0].shape						)	,			[self.batch_size, self.hidden_sizes[1], 4, 4]						)

												# verify channels
												self.parent.assertEqual(len(model.channels						)	,			len(config.out_features						)						)
												self.parent.assertListEqual(model.channels	,			config.hidden_sizes[1:]						)

												# verify backbone works with out_features=None
												A						=    None
												A						=    ResNetBackbone(config=__UpperCamelCase						)
												model.to(__UpperCamelCase						)
												model.eval()
												A						=    model(__UpperCamelCase						)

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps						)	,			1						)
												self.parent.assertListEqual(list(result.feature_maps[0].shape						)	,			[self.batch_size, self.hidden_sizes[-1], 1, 1]						)

												# verify channels
												self.parent.assertEqual(len(model.channels						)	,			1						)
												self.parent.assertListEqual(model.channels	,			[config.hidden_sizes[-1]]						)


					def       lowerCamelCase			(   self     :List[Any]						):
												A						=    self.prepare_config_and_inputs()
												A,      A,      A						=    config_and_inputs
												A						=    {"pixel_values": pixel_values}
												return config, inputs_dict







@require_torch
class    _UpperCAmelCase  (      lowercase_	,				lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				(
					    (
					        ResNetModel,
					        ResNetForImageClassification,
					        ResNetBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					UpperCamelCase						=				(
					    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					UpperCamelCase						=				True
					UpperCamelCase						=				False
					UpperCamelCase						=				False
					UpperCamelCase						=				False
					UpperCamelCase						=				False


					def       lowerCamelCase			(   self     :List[Any]						):
												A						=    ResNetModelTester(self						)
												A						=    ConfigTester(self	,			config_class=__UpperCamelCase	,			has_text_modality=__UpperCamelCase						)


					def       lowerCamelCase			(   self     :List[Any]						):
												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												return


					@unittest.skip(reason="ResNet does not use inputs_embeds"						)
					def       lowerCamelCase			(   self     :Optional[int]						):
												pass


					@unittest.skip(reason="ResNet does not support input and output embeddings"						)
					def       lowerCamelCase			(   self     :Optional[Any]						):
												pass


					def       lowerCamelCase			(   self     :List[Any]						):
												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()

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

																			A						=    ["pixel_values"]
																			self.assertListEqual(arg_names[:1]	,			__UpperCamelCase						)


					def       lowerCamelCase			(   self     :Tuple						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase						)


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*__UpperCamelCase						)


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			A						=    model_class(config=__UpperCamelCase						)
																			for name, module in model.named_modules():
																										if isinstance(__UpperCamelCase	,			(nn.BatchNormad, nn.GroupNorm)						):
																																	self.assertTrue(
																																	    torch.all(module.weight == 1						)	,			msg=f"Parameter {name} of model {model_class} seems not properly initialized"	,			)
																																	self.assertTrue(
																																	    torch.all(module.bias == 0						)	,			msg=f"Parameter {name} of model {model_class} seems not properly initialized"	,			)


					def       lowerCamelCase			(   self     :Optional[Any]						):
												def check_hidden_states_output(__UpperCamelCase     :int	,			__UpperCamelCase     :Any	,			__UpperCamelCase     :Union[str, Any]						):
																			A						=    model_class(__UpperCamelCase						)
																			model.to(__UpperCamelCase						)
																			model.eval()

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

																			A						=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																			A						=    self.model_tester.num_stages
																			self.assertEqual(len(__UpperCamelCase						)	,			expected_num_stages + 1						)

																			# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
																			self.assertListEqual(
																			    list(hidden_states[0].shape[-2:]						)	,			[self.model_tester.image_size // 4, self.model_tester.image_size // 4]	,			)

												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()
												A						=    ["basic", "bottleneck"]
												for model_class in self.all_model_classes:
																			for layer_type in layers_type:
																										A						=    layer_type
																										A						=    True
																										check_hidden_states_output(__UpperCamelCase	,			__UpperCamelCase	,			__UpperCamelCase						)

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

																										check_hidden_states_output(__UpperCamelCase	,			__UpperCamelCase	,			__UpperCamelCase						)


					@unittest.skip(reason="ResNet does not use feedforward chunking"						)
					def       lowerCamelCase			(   self     :Tuple						):
												pass


					def       lowerCamelCase			(   self     :Optional[int]						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase						)


					@slow
					def       lowerCamelCase			(   self     :Union[str, Any]						):
												for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			A						=    ResNetModel.from_pretrained(__UpperCamelCase						)
																			self.assertIsNotNone(__UpperCamelCase						)







def    A__							(     ):
							A						=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
							return image






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


					@cached_property
					def       lowerCamelCase			(   self     :List[Any]						):
												return (
												    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
												    if is_vision_available()
												    else None
												)


					@slow
					def       lowerCamelCase			(   self     :Dict						):
												A						=    ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(__UpperCamelCase						)

												A						=    self.default_image_processor
												A						=    prepare_img()
												A						=    image_processor(images=__UpperCamelCase	,			return_tensors="pt"						).to(__UpperCamelCase						)

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

												# verify the logits
												A						=    torch.Size((1, 10_00)						)
												self.assertEqual(outputs.logits.shape	,			__UpperCamelCase						)

												A						=    torch.tensor([-11.1_069, -9.7_877, -8.3_777]						).to(__UpperCamelCase						)

												self.assertTrue(torch.allclose(outputs.logits[0, :3]	,			__UpperCamelCase	,			atol=1e-4						)						)







@require_torch
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				(ResNetBackbone,) if is_torch_available() else ()
					UpperCamelCase						=				False
					UpperCamelCase						=				ResNetConfig


					def       lowerCamelCase			(   self     :Dict						):
												A						=    ResNetModelTester(self						)









"""simple docstring"""
import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
		from .tokenization_mbartaa import MBartaaTokenizer
else:
		_snake_case	:						Dict					=					None


_snake_case	:						int					=					logging.get_logger(__name__)

_snake_case	:						Optional[Any]					=					{'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}

_snake_case	:						str					=					{
    'vocab_file': {
        'facebook/mbart-large-50-one-to-many-mmt': (
            'https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model'
        ),
    },
    'tokenizer_file': {
        'facebook/mbart-large-50-one-to-many-mmt': (
            'https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/tokenizer.json'
        ),
    },
}

_snake_case	:						Union[str, Any]					=					{
    'facebook/mbart-large-50-one-to-many-mmt': 1024,
}

# fmt: off
_snake_case	:						int					=					['ar_AR', 'cs_CZ', 'de_DE', 'en_XX', 'es_XX', 'et_EE', 'fi_FI', 'fr_XX', 'gu_IN', 'hi_IN', 'it_IT', 'ja_XX', 'kk_KZ', 'ko_KR', 'lt_LT', 'lv_LV', 'my_MM', 'ne_NP', 'nl_XX', 'ro_RO', 'ru_RU', 'si_LK', 'tr_TR', 'vi_VN', 'zh_CN', 'af_ZA', 'az_AZ', 'bn_IN', 'fa_IR', 'he_IL', 'hr_HR', 'id_ID', 'ka_GE', 'km_KH', 'mk_MK', 'ml_IN', 'mn_MN', 'mr_IN', 'pl_PL', 'ps_AF', 'pt_XX', 'sv_SE', 'sw_KE', 'ta_IN', 'te_IN', 'th_TH', 'tl_XX', 'uk_UA', 'ur_PK', 'xh_ZA', 'gl_ES', 'sl_SI']






class    _UpperCAmelCase  (      lowercase_					):
					UpperCamelCase						=				VOCAB_FILES_NAMES
					UpperCamelCase						=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					UpperCamelCase						=				PRETRAINED_VOCAB_FILES_MAP
					UpperCamelCase						=				['''input_ids''', '''attention_mask''']
					UpperCamelCase						=				MBartaaTokenizer

					UpperCamelCase						=				[]
					UpperCamelCase						=				[]


					def __init__(   self     :Any	,			__UpperCamelCase     :str=None	,			__UpperCamelCase     :Any=None	,			__UpperCamelCase     :int=None	,			__UpperCamelCase     :Union[str, Any]=None	,			__UpperCamelCase     :Optional[Any]="</s>"	,			__UpperCamelCase     :Tuple="</s>"	,			__UpperCamelCase     :Any="<s>"	,			__UpperCamelCase     :Optional[int]="<unk>"	,			__UpperCamelCase     :str="<pad>"	,			__UpperCamelCase     :int="<mask>"	,			**__UpperCamelCase     :List[str]	,			):
												# Mask token behave like a normal word, i.e. include the space before it
												A						=    AddedToken(__UpperCamelCase	,			lstrip=__UpperCamelCase	,			rstrip=__UpperCamelCase						) if isinstance(__UpperCamelCase	,			__UpperCamelCase						) else mask_token

												A						=    kwargs.get("additional_special_tokens"	,			[]						)
												kwargs["additional_special_tokens"] += [
												    code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
												]

												super().__init__(
												    __UpperCamelCase	,			src_lang=__UpperCamelCase	,			tgt_lang=__UpperCamelCase	,			tokenizer_file=__UpperCamelCase	,			eos_token=__UpperCamelCase	,			sep_token=__UpperCamelCase	,			cls_token=__UpperCamelCase	,			unk_token=__UpperCamelCase	,			pad_token=__UpperCamelCase	,			mask_token=__UpperCamelCase	,			**__UpperCamelCase	,			)

												A						=    vocab_file
												A						=    False if not self.vocab_file else True

												A						=    {
												    lang_code: self.convert_tokens_to_ids(__UpperCamelCase						) for lang_code in FAIRSEQ_LANGUAGE_CODES
												}

												A						=    src_lang if src_lang is not None else "en_XX"
												A						=    tgt_lang
												A						=    self.lang_code_to_id[self._src_lang]
												self.set_src_lang_special_tokens(self._src_lang						)


					@property
					def       lowerCamelCase			(   self     :int						):
												return self._src_lang


					@src_lang.setter
					def       lowerCamelCase			(   self     :Optional[int]	,			__UpperCamelCase     :str						):
												A						=    new_src_lang
												self.set_src_lang_special_tokens(self._src_lang						)


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :List[int]	,			__UpperCamelCase     :Optional[List[int]] = None						):
												if token_ids_a is None:
																			return self.prefix_tokens + token_ids_a + self.suffix_tokens
												# We don't expect to process pairs, but leave the pair logic for API consistency
												return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :List[str]	,			__UpperCamelCase     :str = "en_XX"	,			__UpperCamelCase     :Optional[List[str]] = None	,			__UpperCamelCase     :str = "ro_RO"	,			**__UpperCamelCase     :Tuple	,			):
												A						=    src_lang
												A						=    tgt_lang
												return super().prepare_seqaseq_batch(__UpperCamelCase	,			__UpperCamelCase	,			**__UpperCamelCase						)


					def       lowerCamelCase			(   self     :str						):
												return self.set_src_lang_special_tokens(self.src_lang						)


					def       lowerCamelCase			(   self     :Optional[Any]						):
												return self.set_tgt_lang_special_tokens(self.tgt_lang						)


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :str						):
												A						=    self.convert_tokens_to_ids(__UpperCamelCase						)
												A						=    [self.cur_lang_code_id]
												A						=    [self.eos_token_id]

												A						=    self.convert_ids_to_tokens(self.prefix_tokens						)
												A						=    self.convert_ids_to_tokens(self.suffix_tokens						)

												A						=    processors.TemplateProcessing(
												    single=prefix_tokens_str + ["$A"] + suffix_tokens_str	,			pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str	,			special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str	,			self.prefix_tokens + self.suffix_tokens						)						)	,			)


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :str						):
												A						=    self.convert_tokens_to_ids(__UpperCamelCase						)
												A						=    [self.cur_lang_code_id]
												A						=    [self.eos_token_id]

												A						=    self.convert_ids_to_tokens(self.prefix_tokens						)
												A						=    self.convert_ids_to_tokens(self.suffix_tokens						)

												A						=    processors.TemplateProcessing(
												    single=prefix_tokens_str + ["$A"] + suffix_tokens_str	,			pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str	,			special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str	,			self.prefix_tokens + self.suffix_tokens						)						)	,			)


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Any	,			__UpperCamelCase     :str	,			__UpperCamelCase     :Optional[str]	,			__UpperCamelCase     :Optional[str]	,			**__UpperCamelCase     :Union[str, Any]						):
												if src_lang is None or tgt_lang is None:
																			raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"						)
												A						=    src_lang
												A						=    self(__UpperCamelCase	,			add_special_tokens=__UpperCamelCase	,			return_tensors=__UpperCamelCase	,			**__UpperCamelCase						)
												A						=    self.convert_tokens_to_ids(__UpperCamelCase						)
												A						=    tgt_lang_id
												return inputs


					def       lowerCamelCase			(   self     :Tuple	,			__UpperCamelCase     :str	,			__UpperCamelCase     :Optional[str] = None						):
												if not self.can_save_slow_tokenizer:
																			raise ValueError(
																			    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
																			    "tokenizer."						)

												if not os.path.isdir(__UpperCamelCase						):
																			logger.error(f"Vocabulary path ({save_directory}) should be a directory"						)
																			return
												A						=    os.path.join(
												    __UpperCamelCase	,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)

												if os.path.abspath(self.vocab_file						) != os.path.abspath(__UpperCamelCase						):
																			copyfile(self.vocab_file	,			__UpperCamelCase						)

												return (out_vocab_file,)


