

'''simple docstring'''


import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


lowerCAmelCase__										= logging.get_logger(__name__)

lowerCAmelCase__										= "▁"

lowerCAmelCase__										= {"vocab_file": "sentencepiece.bpe.model"}

lowerCAmelCase__										= {
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model"
        ),
    }
}

lowerCAmelCase__										= {
    "facebook/nllb-200-distilled-600M": 1024,
}

# fmt: off
lowerCAmelCase__										= ["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      Optional[int]=   VOCAB_FILES_NAMES
							_lowerCamelCase		:      Dict=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							_lowerCamelCase		:      str=   PRETRAINED_VOCAB_FILES_MAP
							_lowerCamelCase		:      Any=   ["input_ids", "attention_mask"]

							_lowerCamelCase		:      List[int]=   []
							_lowerCamelCase		:      List[int]=   []


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

								UpperCAmelCase_		:      str       	=					{} if sp_model_kwargs is None else sp_model_kwargs
								UpperCAmelCase_		:      List[str]       	=					legacy_behaviour

								super().__init__(
								    bos_token=_snake_case    ,			eos_token=_snake_case    ,			unk_token=_snake_case    ,			sep_token=_snake_case    ,			cls_token=_snake_case    ,			pad_token=_snake_case    ,			mask_token=_snake_case    ,			tokenizer_file=_snake_case    ,			src_lang=_snake_case    ,			tgt_lang=_snake_case    ,			additional_special_tokens=_snake_case    ,			sp_model_kwargs=self.sp_model_kwargs    ,			legacy_behaviour=_snake_case    ,			**_snake_case    ,			)

								UpperCAmelCase_		:      int       	=					spm.SentencePieceProcessor(**self.sp_model_kwargs)
								self.sp_model.Load(str(_snake_case))
								UpperCAmelCase_		:      List[Any]       	=					vocab_file
								# Original fairseq vocab and spm vocab must be "aligned":
								# Vocab    |    0    |    1    |   2    |    3    |  4   |  5   |  6   |   7  |   8  |  9
								# -------- | ------- | ------- | ------ | ------- | ---- | ---- | ---- | ---- | ---- | ----
								# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a'
								# spm      | '<unk>' | '<s>'   | '</s>' | 'an'    | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s'

								# Mimic fairseq token-to-id alignment for the first 4 token
								UpperCAmelCase_		:      Dict       	=					{'<s>': 0, '<pad>': 1, '</s>': 2, '<unk>': 3}

								# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
								UpperCAmelCase_		:      str       	=					1

								UpperCAmelCase_		:      Union[str, Any]       	=					len(self.sp_model)
								UpperCAmelCase_		:      Optional[Any]       	=					{
								    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(_snake_case)
								}
								UpperCAmelCase_		:      List[str]       	=					{v: k for k, v in self.lang_code_to_id.items()}
								UpperCAmelCase_		:      Any       	=					len(self.sp_model) + len(self.lang_code_to_id) + self.fairseq_offset

								self.fairseq_tokens_to_ids.update(self.lang_code_to_id)
								UpperCAmelCase_		:      Union[str, Any]       	=					{v: k for k, v in self.fairseq_tokens_to_ids.items()}
								UpperCAmelCase_		:      List[str]       	=					list(self.lang_code_to_id.keys())

								if additional_special_tokens is not None:
									# Only add those special tokens if they are not already there.
									self._additional_special_tokens.extend(
									    [t for t in additional_special_tokens if t not in self._additional_special_tokens])

								UpperCAmelCase_		:      int       	=					src_lang if src_lang is not None else 'eng_Latn'
								UpperCAmelCase_		:      Dict       	=					self.lang_code_to_id[self._src_lang]
								UpperCAmelCase_		:      List[str]       	=					tgt_lang
								self.set_src_lang_special_tokens(self._src_lang)


							def __getstate__(			self)							->				Any:
								UpperCAmelCase_		:      List[str]       	=					self.__dict__.copy()
								UpperCAmelCase_		:      Any       	=					None
								UpperCAmelCase_		:      str       	=					self.sp_model.serialized_model_proto()
								return state


							def __setstate__(			self    ,			_snake_case)							->				Optional[Any]:
								UpperCAmelCase_		:      Dict       	=					d

								# for backward compatibility
								if not hasattr(self    ,			'sp_model_kwargs'):
									UpperCAmelCase_		:      str       	=					{}

								UpperCAmelCase_		:      Dict       	=					spm.SentencePieceProcessor(**self.sp_model_kwargs)
								self.sp_model.LoadFromSerializedProto(self.sp_model_proto)


							@property
							def 						_snake_case							(			self)							->				List[str]:
								return len(self.sp_model) + len(self.lang_code_to_id) + self.fairseq_offset + 1  # Plus 1 for the mask token


							@property
							def 						_snake_case							(			self)							->				str:
								return self._src_lang


							@src_lang.setter
							def 						_snake_case							(			self    ,			_snake_case)							->				None:
								UpperCAmelCase_		:      Optional[int]       	=					new_src_lang
								self.set_src_lang_special_tokens(self._src_lang)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = None    ,			_snake_case = False)							->				List[int]:

								if already_has_special_tokens:
									return super().get_special_tokens_mask(
									    token_ids_a=_snake_case    ,			token_ids_a=_snake_case    ,			already_has_special_tokens=_snake_case)

								UpperCAmelCase_		:      List[str]       	=					[1] * len(self.prefix_tokens)
								UpperCAmelCase_		:      List[Any]       	=					[1] * len(self.suffix_tokens)
								if token_ids_a is None:
									return prefix_ones + ([0] * len(_snake_case)) + suffix_ones
								return prefix_ones + ([0] * len(_snake_case)) + ([0] * len(_snake_case)) + suffix_ones


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = None)							->				List[int]:
								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 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = None)							->				List[int]:
								UpperCAmelCase_		:      str       	=					[self.sep_token_id]
								UpperCAmelCase_		:      Dict       	=					[self.cls_token_id]

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


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			**_snake_case)							->				List[str]:
								if src_lang is None or tgt_lang is None:
									raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model')
								UpperCAmelCase_		:      Any       	=					src_lang
								UpperCAmelCase_		:      List[Any]       	=					self(_snake_case    ,			add_special_tokens=_snake_case    ,			return_tensors=_snake_case    ,			**_snake_case)
								UpperCAmelCase_		:      int       	=					self.convert_tokens_to_ids(_snake_case)
								UpperCAmelCase_		:      Dict       	=					tgt_lang_id
								return inputs


							def 						_snake_case							(			self)							->				Dict:
								UpperCAmelCase_		:      Union[str, Any]       	=					{self.convert_ids_to_tokens(_snake_case): i for i in range(self.vocab_size)}
								vocab.update(self.added_tokens_encoder)
								return vocab


							def 						_snake_case							(			self    ,			_snake_case)							->				List[str]:
								return self.sp_model.encode(_snake_case    ,			out_type=_snake_case)


							def 						_snake_case							(			self    ,			_snake_case)							->				Any:
								if token in self.fairseq_tokens_to_ids:
									return self.fairseq_tokens_to_ids[token]
								UpperCAmelCase_		:      int       	=					self.sp_model.PieceToId(_snake_case)

								# Need to return unknown token if the SP model returned 0
								return spm_id + self.fairseq_offset if spm_id else self.unk_token_id


							def 						_snake_case							(			self    ,			_snake_case)							->				List[Any]:
								if index in self.fairseq_ids_to_tokens:
									return self.fairseq_ids_to_tokens[index]
								return self.sp_model.IdToPiece(index - self.fairseq_offset)


							def 						_snake_case							(			self    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      Any       	=					''.join(_snake_case).replace(_snake_case    ,			' ').strip()
								return out_string


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

								if os.path.abspath(self.vocab_file) != os.path.abspath(_snake_case) and os.path.isfile(self.vocab_file):
									copyfile(self.vocab_file    ,			_snake_case)
								elif not os.path.isfile(self.vocab_file):
									with open(_snake_case    ,			'wb') as fi:
										UpperCAmelCase_		:      Optional[int]       	=					self.sp_model.serialized_model_proto()
										fi.write(_snake_case)

								return (out_vocab_file,)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = "eng_Latn"    ,			_snake_case = None    ,			_snake_case = "fra_Latn"    ,			**_snake_case    ,			)							->				BatchEncoding:
								UpperCAmelCase_		:      Optional[Any]       	=					src_lang
								UpperCAmelCase_		:      Dict       	=					tgt_lang
								return super().prepare_seqaseq_batch(_snake_case    ,			_snake_case    ,			**_snake_case)


							def 						_snake_case							(			self)							->				str:
								return self.set_src_lang_special_tokens(self.src_lang)


							def 						_snake_case							(			self)							->				Union[str, Any]:
								return self.set_tgt_lang_special_tokens(self.tgt_lang)


							def 						_snake_case							(			self    ,			_snake_case)							->				None:
								UpperCAmelCase_		:      str       	=					self.lang_code_to_id[src_lang]
								if self.legacy_behaviour:
									UpperCAmelCase_		:      Dict       	=					[]
									UpperCAmelCase_		:      Optional[int]       	=					[self.eos_token_id, self.cur_lang_code]
								else:
									UpperCAmelCase_		:      str       	=					[self.cur_lang_code]
									UpperCAmelCase_		:      Dict       	=					[self.eos_token_id]





							def 						_snake_case							(			self    ,			_snake_case)							->				None:
								UpperCAmelCase_		:      Union[str, Any]       	=					self.lang_code_to_id[lang]
								if self.legacy_behaviour:
									UpperCAmelCase_		:      str       	=					[]
									UpperCAmelCase_		:      int       	=					[self.eos_token_id, self.cur_lang_code]
								else:
									UpperCAmelCase_		:      Tuple       	=					[self.cur_lang_code]
									UpperCAmelCase_		:      List[Any]       	=					[self.eos_token_id]









'''simple docstring'''


from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCAmelCase__										= logging.get_logger(__name__)

lowerCAmelCase__										= {
    "microsoft/swin-tiny-patch4-window7-224": (
        "https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json"
    ),
    # See all Swin models at https://huggingface.co/models?filter=swin
}



class 					lowercase						(  a_,					a_ ):
							_lowerCamelCase		:      Optional[int]=   "swin"

							_lowerCamelCase		:      Dict=   {
							    "num_attention_heads": "num_heads",
							    "num_hidden_layers": "num_layers",
							}


							def __init__(			self    ,			_snake_case=224    ,			_snake_case=4    ,			_snake_case=3    ,			_snake_case=96    ,			_snake_case=[2, 2, 6, 2]    ,			_snake_case=[3, 6, 12, 24]    ,			_snake_case=7    ,			_snake_case=4.0    ,			_snake_case=True    ,			_snake_case=0.0    ,			_snake_case=0.0    ,			_snake_case=0.1    ,			_snake_case="gelu"    ,			_snake_case=False    ,			_snake_case=0.02    ,			_snake_case=1e-5    ,			_snake_case=32    ,			_snake_case=None    ,			_snake_case=None    ,			**_snake_case    ,			)							->				Tuple:
								super().__init__(**_snake_case)

								UpperCAmelCase_		:      Any       	=					image_size
								UpperCAmelCase_		:      Dict       	=					patch_size
								UpperCAmelCase_		:      int       	=					num_channels
								UpperCAmelCase_		:      Tuple       	=					embed_dim
								UpperCAmelCase_		:      Dict       	=					depths
								UpperCAmelCase_		:      Dict       	=					len(_snake_case)
								UpperCAmelCase_		:      List[Any]       	=					num_heads
								UpperCAmelCase_		:      Optional[int]       	=					window_size
								UpperCAmelCase_		:      Any       	=					mlp_ratio
								UpperCAmelCase_		:      Any       	=					qkv_bias
								UpperCAmelCase_		:      str       	=					hidden_dropout_prob
								UpperCAmelCase_		:      Optional[int]       	=					attention_probs_dropout_prob
								UpperCAmelCase_		:      Dict       	=					drop_path_rate
								UpperCAmelCase_		:      int       	=					hidden_act
								UpperCAmelCase_		:      Tuple       	=					use_absolute_embeddings
								UpperCAmelCase_		:      Optional[int]       	=					layer_norm_eps
								UpperCAmelCase_		:      Optional[int]       	=					initializer_range
								UpperCAmelCase_		:      Optional[Any]       	=					encoder_stride
								# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
								# this indicates the channel dimension after the last stage of the model
								UpperCAmelCase_		:      Union[str, Any]       	=					int(embed_dim * 2 ** (len(_snake_case) - 1))
								UpperCAmelCase_		:      Tuple       	=					['stem'] + [F"""stage{idx}""" for idx in range(1    ,			len(_snake_case) + 1)]
								UpperCAmelCase_	,    UpperCAmelCase_		:      Dict       	=					get_aligned_output_features_output_indices(
								    out_features=_snake_case    ,			out_indices=_snake_case    ,			stage_names=self.stage_names)



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      Tuple=   version.parse("1.11" )


							@property
							def 						_snake_case							(			self)							->				Mapping[str, Mapping[int, str]]:
								return OrderedDict(
								    [
								        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
								    ])





							@property
							def 						_snake_case							(			self)							->				float:
								return 1e-4






