"""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__  :  Optional[int]						     =	logging.get_logger(__name__)

lowerCAmelCase__  :  Any						     =	'''▁'''

lowerCAmelCase__  :  List[str]						     =	{'''vocab_file''': '''sentencepiece.bpe.model'''}

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

lowerCAmelCase__  :  List[Any]						     =	{
    '''facebook/nllb-200-distilled-600M''': 1_024,
}

# fmt: off
lowerCAmelCase__  :  int						     =	['''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 				snake_case       ( lowerCAmelCase__				):




					"""simple docstring"""

					snake_case__				    = VOCAB_FILES_NAMES
					snake_case__				    = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					snake_case__				    = PRETRAINED_VOCAB_FILES_MAP
					snake_case__				    = ["""input_ids""", """attention_mask"""]

					snake_case__				    = []
					snake_case__				    = []







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

									UpperCAmelCase__             =							{} if sp_model_kwargs is None else sp_model_kwargs
									UpperCAmelCase__             =							legacy_behaviour

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

									UpperCAmelCase__             =							spm.SentencePieceProcessor(**self.sp_model_kwargs			)
									self.sp_model.Load(str(lowercase_			)			)
									UpperCAmelCase__             =							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__             =							{'''<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__             =							1

									UpperCAmelCase__             =							len(self.sp_model			)
									UpperCAmelCase__             =							{
									    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(lowercase_			)
									}
									UpperCAmelCase__             =							{v: k for k, v in self.lang_code_to_id.items()}
									UpperCAmelCase__             =							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__             =							{v: k for k, v in self.fairseq_tokens_to_ids.items()}
									UpperCAmelCase__             =							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__             =							src_lang if src_lang is not None else '''eng_Latn'''
									UpperCAmelCase__             =							self.lang_code_to_id[self._src_lang]
									UpperCAmelCase__             =							tgt_lang
									self.set_src_lang_special_tokens(self._src_lang			)







					def __getstate__(				self   :	List[Any]			):
									UpperCAmelCase__             =							self.__dict__.copy()
									UpperCAmelCase__             =							None
									UpperCAmelCase__             =							self.sp_model.serialized_model_proto()
									return state







					def __setstate__(				self   :	Dict    ,lowerCamelCase__   :	Tuple			):
									UpperCAmelCase__             =							d

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

									UpperCAmelCase__             =							spm.SentencePieceProcessor(**self.sp_model_kwargs			)
									self.sp_model.LoadFromSerializedProto(self.sp_model_proto			)







					@property
					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									return len(self.sp_model			) + len(self.lang_code_to_id			) + self.fairseq_offset + 1  # Plus 1 for the mask token







					@property
					def 		__lowerCAmelCase						(				self   :	Optional[int]			):
									return self._src_lang







					@src_lang.setter
					def 		__lowerCAmelCase						(				self   :	Any    ,lowerCamelCase__   :	str			):
									UpperCAmelCase__             =							new_src_lang
									self.set_src_lang_special_tokens(self._src_lang			)







					def 		__lowerCAmelCase						(				self   :	Optional[Any]    ,lowerCamelCase__   :	List[int]    ,lowerCamelCase__   :	Optional[List[int]] = None    ,lowerCamelCase__   :	bool = False			):

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

									UpperCAmelCase__             =							[1] * len(self.prefix_tokens			)
									UpperCAmelCase__             =							[1] * len(self.suffix_tokens			)
									if token_ids_a is None:
													return prefix_ones + ([0] * len(lowercase_			)) + suffix_ones
									return prefix_ones + ([0] * len(lowercase_			)) + ([0] * len(lowercase_			)) + suffix_ones







					def 		__lowerCAmelCase						(				self   :	List[Any]    ,lowerCamelCase__   :	List[int]    ,lowerCamelCase__   :	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   :	str    ,lowerCamelCase__   :	List[int]    ,lowerCamelCase__   :	Optional[List[int]] = None			):
									UpperCAmelCase__             =							[self.sep_token_id]
									UpperCAmelCase__             =							[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 		__lowerCAmelCase						(				self   :	List[str]    ,lowerCamelCase__   :	Union[str, Any]    ,lowerCamelCase__   :	str    ,lowerCamelCase__   :	Optional[str]    ,lowerCamelCase__   :	Optional[str]    ,**lowerCamelCase__   :	Tuple			):
									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__             =							src_lang
									UpperCAmelCase__             =							self(lowercase_    ,add_special_tokens=lowercase_    ,return_tensors=lowercase_    ,**lowercase_			)
									UpperCAmelCase__             =							self.convert_tokens_to_ids(lowercase_			)
									UpperCAmelCase__             =							tgt_lang_id
									return inputs







					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									UpperCAmelCase__             =							{self.convert_ids_to_tokens(lowercase_			): i for i in range(self.vocab_size			)}
									vocab.update(self.added_tokens_encoder			)
									return vocab







					def 		__lowerCAmelCase						(				self   :	Optional[Any]    ,lowerCamelCase__   :	str			):
									return self.sp_model.encode(lowercase_    ,out_type=lowercase_			)







					def 		__lowerCAmelCase						(				self   :	int    ,lowerCamelCase__   :	List[Any]			):
									if token in self.fairseq_tokens_to_ids:
													return self.fairseq_tokens_to_ids[token]
									UpperCAmelCase__             =							self.sp_model.PieceToId(lowercase_			)

									# 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 		__lowerCAmelCase						(				self   :	List[str]    ,lowerCamelCase__   :	Optional[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 		__lowerCAmelCase						(				self   :	Tuple    ,lowerCamelCase__   :	Optional[int]			):
									UpperCAmelCase__             =							''''''.join(lowercase_			).replace(lowercase_    ,' '			).strip()
									return out_string







					def 		__lowerCAmelCase						(				self   :	Optional[Any]    ,lowerCamelCase__   :	str    ,lowerCamelCase__   :	Optional[str] = None			):
									if not os.path.isdir(lowercase_			):
													logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''			)
													return
									UpperCAmelCase__             =							os.path.join(
									    lowercase_    ,(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)

									if os.path.abspath(self.vocab_file			) != os.path.abspath(lowercase_			) and os.path.isfile(self.vocab_file			):
													copyfile(self.vocab_file    ,lowercase_			)
									elif not os.path.isfile(self.vocab_file			):
													with open(lowercase_    ,'wb'			) as fi:
																	UpperCAmelCase__             =							self.sp_model.serialized_model_proto()
																	fi.write(lowercase_			)

									return (out_vocab_file,)







					def 		__lowerCAmelCase						(				self   :	Optional[Any]    ,lowerCamelCase__   :	List[str]    ,lowerCamelCase__   :	str = "eng_Latn"    ,lowerCamelCase__   :	Optional[List[str]] = None    ,lowerCamelCase__   :	str = "fra_Latn"    ,**lowerCamelCase__   :	Dict    ,):
									UpperCAmelCase__             =							src_lang
									UpperCAmelCase__             =							tgt_lang
									return super().prepare_seqaseq_batch(lowercase_    ,lowercase_    ,**lowercase_			)







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







					def 		__lowerCAmelCase						(				self   :	List[str]			):
									return self.set_tgt_lang_special_tokens(self.tgt_lang			)







					def 		__lowerCAmelCase						(				self   :	Optional[int]    ,lowerCamelCase__   :	int			):
									UpperCAmelCase__             =							self.lang_code_to_id[src_lang]
									if self.legacy_behaviour:
													UpperCAmelCase__             =							[]
													UpperCAmelCase__             =							[self.eos_token_id, self.cur_lang_code]
									else:
													UpperCAmelCase__             =							[self.cur_lang_code]
													UpperCAmelCase__             =							[self.eos_token_id]







					def 		__lowerCAmelCase						(				self   :	Any    ,lowerCamelCase__   :	str			):
									UpperCAmelCase__             =							self.lang_code_to_id[lang]
									if self.legacy_behaviour:
													UpperCAmelCase__             =							[]
													UpperCAmelCase__             =							[self.eos_token_id, self.cur_lang_code]
									else:
													UpperCAmelCase__             =							[self.cur_lang_code]
													UpperCAmelCase__             =							[self.eos_token_id]








"""simple docstring"""

import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
         OpenAIGPTConfig,
         OpenAIGPTDoubleHeadsModel,
         OpenAIGPTForSequenceClassification,
         OpenAIGPTLMHeadModel,
         OpenAIGPTModel,
     )




class        _UpperCAmelCase       :

 def __init__(     self		:       Union[str, Any]  ,     lowercase_		:       List[Any]  ,     lowercase_		:       int=13  ,     lowercase_		:       Optional[int]=7  ,     lowercase_		:       Any=True  ,     lowercase_		:       Dict=True  ,     lowercase_		:       Dict=True  ,     lowercase_		:       Optional[Any]=99  ,     lowercase_		:       Union[str, Any]=32  ,     lowercase_		:       str=5  ,     lowercase_		:       Union[str, Any]=4  ,     lowercase_		:       Any=37  ,     lowercase_		:       Tuple="gelu"  ,     lowercase_		:       Dict=0.1  ,     lowercase_		:       Tuple=0.1  ,     lowercase_		:       Optional[int]=512  ,     lowercase_		:       Optional[Any]=16  ,     lowercase_		:       Optional[Any]=2  ,     lowercase_		:       Optional[Any]=0.02  ,     lowercase_		:       List[Any]=3  ,     lowercase_		:       Union[str, Any]=4  ,     lowercase_		:       List[Any]=None  ,     ):
     snake_case_ :     Any				=	parent
     snake_case_ :     List[str]				=	batch_size
     snake_case_ :     List[Any]				=	seq_length
     snake_case_ :     Optional[int]				=	is_training
     snake_case_ :     Union[str, Any]				=	use_token_type_ids
     snake_case_ :     Optional[Any]				=	use_labels
     snake_case_ :     Union[str, Any]				=	vocab_size
     snake_case_ :     Any				=	hidden_size
     snake_case_ :     List[Any]				=	num_hidden_layers
     snake_case_ :     Any				=	num_attention_heads
     snake_case_ :     Dict				=	intermediate_size
     snake_case_ :     Union[str, Any]				=	hidden_act
     snake_case_ :     Optional[int]				=	hidden_dropout_prob
     snake_case_ :     Optional[Any]				=	attention_probs_dropout_prob
     snake_case_ :     Tuple				=	max_position_embeddings
     snake_case_ :     int				=	type_vocab_size
     snake_case_ :     Tuple				=	type_sequence_label_size
     snake_case_ :     str				=	initializer_range
     snake_case_ :     Tuple				=	num_labels
     snake_case_ :     str				=	num_choices
     snake_case_ :     Any				=	scope
     snake_case_ :     Dict				=	self.vocab_size - 1

 def 						_snake_case					(     self		:       int				):
     snake_case_ :     Optional[Any]				=	ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)

     snake_case_ :     Optional[Any]				=	None
     if self.use_token_type_ids:
         snake_case_ :     Tuple				=	ids_tensor([self.batch_size, self.seq_length]  ,     self.type_vocab_size				)

     snake_case_ :     str				=	None
     snake_case_ :     Dict				=	None
     snake_case_ :     str				=	None
     if self.use_labels:
         snake_case_ :     Optional[int]				=	ids_tensor([self.batch_size]  ,     self.type_sequence_label_size				)
         snake_case_ :     List[Any]				=	ids_tensor([self.batch_size, self.seq_length]  ,     self.num_labels				)
         snake_case_ :     Tuple				=	ids_tensor([self.batch_size]  ,     self.num_choices				)

     snake_case_ :     int				=	OpenAIGPTConfig(
         vocab_size=self.vocab_size  ,     n_embd=self.hidden_size  ,     n_layer=self.num_hidden_layers  ,     n_head=self.num_attention_heads  ,     n_positions=self.max_position_embeddings  ,     pad_token_id=self.pad_token_id  ,     )

     snake_case_ :     Any				=	ids_tensor([self.num_hidden_layers, self.num_attention_heads]  ,     2				)

     return (
         config,
         input_ids,
         head_mask,
         token_type_ids,
         sequence_labels,
         token_labels,
         choice_labels,
     )

 def 						_snake_case					(     self		:       Tuple  ,     lowercase_		:       Any  ,     lowercase_		:       Union[str, Any]  ,     lowercase_		:       str  ,     lowercase_		:       Dict  ,     *lowercase_		:       Dict				):
     snake_case_ :     List[Any]				=	OpenAIGPTModel(config=lowercase_				)
     model.to(lowercase_				)
     model.eval()

     snake_case_ :     Any				=	model(lowercase_  ,     token_type_ids=lowercase_  ,     head_mask=lowercase_				)
     snake_case_ :     Optional[Any]				=	model(lowercase_  ,     token_type_ids=lowercase_				)
     snake_case_ :     Optional[Any]				=	model(lowercase_				)

     self.parent.assertEqual(result.last_hidden_state.shape  ,     (self.batch_size, self.seq_length, self.hidden_size)				)

 def 						_snake_case					(     self		:       Tuple  ,     lowercase_		:       Dict  ,     lowercase_		:       str  ,     lowercase_		:       Optional[Any]  ,     lowercase_		:       List[Any]  ,     *lowercase_		:       Optional[Any]				):
     snake_case_ :     Union[str, Any]				=	OpenAIGPTLMHeadModel(lowercase_				)
     model.to(lowercase_				)
     model.eval()

     snake_case_ :     Union[str, Any]				=	model(lowercase_  ,     token_type_ids=lowercase_  ,     labels=lowercase_				)
     self.parent.assertEqual(result.loss.shape  ,     ()				)
     self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.seq_length, self.vocab_size)				)

 def 						_snake_case					(     self		:       List[str]  ,     lowercase_		:       Dict  ,     lowercase_		:       List[str]  ,     lowercase_		:       Any  ,     lowercase_		:       Dict  ,     *lowercase_		:       Union[str, Any]				):
     snake_case_ :     Tuple				=	OpenAIGPTDoubleHeadsModel(lowercase_				)
     model.to(lowercase_				)
     model.eval()

     snake_case_ :     Dict				=	model(lowercase_  ,     token_type_ids=lowercase_  ,     labels=lowercase_				)
     self.parent.assertEqual(result.loss.shape  ,     ()				)
     self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.seq_length, self.vocab_size)				)

 def 						_snake_case					(     self		:       Any  ,     lowercase_		:       str  ,     lowercase_		:       List[str]  ,     lowercase_		:       Optional[Any]  ,     lowercase_		:       Optional[Any]  ,     *lowercase_		:       Any				):
     snake_case_ :     int				=	self.num_labels
     snake_case_ :     Any				=	OpenAIGPTForSequenceClassification(lowercase_				)
     model.to(lowercase_				)
     model.eval()

     snake_case_ :     Optional[int]				=	ids_tensor([self.batch_size]  ,     self.type_sequence_label_size				)
     snake_case_ :     Optional[Any]				=	model(lowercase_  ,     token_type_ids=lowercase_  ,     labels=lowercase_				)
     self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.num_labels)				)






 def 						_snake_case					(     self		:       int				):
     snake_case_ :     Dict				=	self.prepare_config_and_inputs()
     (
         (
         snake_case_
     ),	(
         snake_case_
     ),	(
         snake_case_
     ),	(
         snake_case_
     ),	(
         snake_case_
     ),	(
         snake_case_
     ),	(
         snake_case_
     ),	
     ) :     str				=	config_and_inputs
     snake_case_ :     str				=	{
         '''input_ids''': input_ids,
         '''token_type_ids''': token_type_ids,
         '''head_mask''': head_mask,
     }

     return config, inputs_dict





@require_torch
class        _UpperCAmelCase       (			lowerCAmelCase__    ,     lowerCAmelCase__    ,     lowerCAmelCase__    ,     unittest.TestCase):
 _lowerCAmelCase   :			Dict							=		(
     (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase   :			int							=		(
     (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
 _lowerCAmelCase   :			Union[str, Any]							=		(
     {
         """feature-extraction""": OpenAIGPTModel,
         """text-classification""": OpenAIGPTForSequenceClassification,
         """text-generation""": OpenAIGPTLMHeadModel,
         """zero-shot""": OpenAIGPTForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )

 def 						_snake_case					(     self		:       Tuple  ,     lowercase_		:       Optional[int]  ,     lowercase_		:       int  ,     lowercase_		:       List[Any]  ,     lowercase_		:       List[Any]  ,     lowercase_		:       Union[str, Any]				):
     if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
         # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
         # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
         # tiny config could not be created.
         return True

     return False

 def 						_snake_case					(     self		:       Optional[int]  ,     lowercase_		:       List[Any]  ,     lowercase_		:       Optional[int]  ,     lowercase_		:       List[str]=False				):
     snake_case_ :     Dict				=	super()._prepare_for_class(lowercase_  ,     lowercase_  ,     return_labels=lowercase_				)

     if return_labels:
         if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
             snake_case_ :     List[str]				=	torch.zeros(
                 (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)  ,     dtype=torch.long  ,     device=lowercase_  ,     )
             snake_case_ :     int				=	inputs_dict['''labels''']
             snake_case_ :     Optional[Any]				=	inputs_dict['''labels''']
             snake_case_ :     int				=	torch.zeros(
                 (self.model_tester.batch_size, self.model_tester.num_choices)  ,     dtype=torch.long  ,     device=lowercase_  ,     )
             snake_case_ :     Tuple				=	torch.zeros(
                 self.model_tester.batch_size  ,     dtype=torch.long  ,     device=lowercase_				)
     return inputs_dict

 def 						_snake_case					(     self		:       Any				):
     snake_case_ :     List[str]				=	OpenAIGPTModelTester(self				)
     snake_case_ :     Dict				=	ConfigTester(self  ,     config_class=lowercase_  ,     n_embd=37				)

 def 						_snake_case					(     self		:       List[str]				):
     self.config_tester.run_common_tests()

 def 						_snake_case					(     self		:       Optional[Any]				):
     snake_case_ :     Tuple				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_openai_gpt_model(*lowercase_				)

 def 						_snake_case					(     self		:       List[str]				):
     snake_case_ :     List[str]				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_lm_head_model(*lowercase_				)

 def 						_snake_case					(     self		:       int				):
     snake_case_ :     Any				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_double_lm_head_model(*lowercase_				)

 def 						_snake_case					(     self		:       List[str]				):
     snake_case_ :     Optional[int]				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase_				)






 @slow
 def 						_snake_case					(     self		:       Dict				):
     for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case_ :     Optional[Any]				=	OpenAIGPTModel.from_pretrained(lowercase_				)
         self.assertIsNotNone(lowercase_				)





@require_torch
class        _UpperCAmelCase       (			unittest.TestCase):

 @slow
 def 						_snake_case					(     self		:       Optional[int]				):
     snake_case_ :     Optional[Any]				=	OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''				)
     model.to(lowercase_				)
     snake_case_ :     List[str]				=	torch.tensor([[481, 4735, 544]]  ,     dtype=torch.long  ,     device=lowercase_				)  # the president is
     snake_case_ :     List[Any]				=	[
         481,
         4735,
         544,
         246,
         963,
         870,
         762,
         239,
         244,
         40477,
         244,
         249,
         719,
         881,
         487,
         544,
         240,
         244,
         603,
         481,
     ]  # the president is a very good man. " \n " i\'m sure he is, " said the

     snake_case_ :     Optional[Any]				=	model.generate(lowercase_  ,     do_sample=lowercase_				)
     self.assertListEqual(output_ids[0].tolist()  ,     lowercase_				)





