
from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers.models.gptj.modeling_tf_gptj import (
			    TFGPTJForCausalLM,
			    TFGPTJForQuestionAnswering,
			    TFGPTJForSequenceClassification,
			    TFGPTJModel,
			    shape_list,
			)





class      _lowerCAmelCase :




				def __init__( self    ,    _UpperCamelCase					)    ->				Optional[Any]:
							lowerCAmelCase_      =     parent
							lowerCAmelCase_      =     13
							lowerCAmelCase_      =     7
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     99
							lowerCAmelCase_      =     32
							lowerCAmelCase_      =     4
							lowerCAmelCase_      =     2
							lowerCAmelCase_      =     4
							lowerCAmelCase_      =     37
							lowerCAmelCase_      =     "gelu"
							lowerCAmelCase_      =     0.1
							lowerCAmelCase_      =     0.1
							lowerCAmelCase_      =     512
							lowerCAmelCase_      =     16
							lowerCAmelCase_      =     2
							lowerCAmelCase_      =     0.02
							lowerCAmelCase_      =     3
							lowerCAmelCase_      =     4
							lowerCAmelCase_      =     None
							lowerCAmelCase_      =     self.vocab_size - 1
							lowerCAmelCase_      =     self.vocab_size - 1
							lowerCAmelCase_      =     self.vocab_size - 1




				def 					__a						( self					)    ->				int:
							lowerCAmelCase_      =     ids_tensor([self.batch_size, self.seq_length]    ,    self.vocab_size					)

							lowerCAmelCase_      =     None
							if self.use_input_mask:
										lowerCAmelCase_      =     random_attention_mask([self.batch_size, self.seq_length]					)

							lowerCAmelCase_      =     None
							if self.use_token_type_ids:
										lowerCAmelCase_      =     ids_tensor([self.batch_size, self.seq_length]    ,    self.type_vocab_size					)

							lowerCAmelCase_      =     None
							if self.use_mc_token_ids:
										lowerCAmelCase_      =     ids_tensor([self.batch_size, self.num_choices]    ,    self.seq_length					)

							lowerCAmelCase_      =     None
							lowerCAmelCase_      =     None
							lowerCAmelCase_      =     None
							if self.use_labels:
										lowerCAmelCase_      =     ids_tensor([self.batch_size]    ,    self.type_sequence_label_size					)
										lowerCAmelCase_      =     ids_tensor([self.batch_size, self.seq_length]    ,    self.num_labels					)
										lowerCAmelCase_      =     ids_tensor([self.batch_size]    ,    self.num_choices					)

							lowerCAmelCase_      =     GPTJConfig(
							    vocab_size=self.vocab_size    ,    n_embd=self.hidden_size    ,    n_layer=self.num_hidden_layers    ,    n_head=self.num_attention_heads    ,    intermediate_size=self.intermediate_size    ,    hidden_act=self.hidden_act    ,    hidden_dropout_prob=self.hidden_dropout_prob    ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,    n_positions=self.max_position_embeddings    ,    type_vocab_size=self.type_vocab_size    ,    initializer_range=self.initializer_range    ,    bos_token_id=self.bos_token_id    ,    eos_token_id=self.eos_token_id    ,    pad_token_id=self.pad_token_id    ,    rotary_dim=self.rotary_dim    ,    return_dict=_UpperCamelCase    ,    )

							lowerCAmelCase_      =     ids_tensor([self.num_hidden_layers, self.num_attention_heads]    ,    2					)

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




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    *_UpperCamelCase					)    ->				List[str]:
							lowerCAmelCase_      =     TFGPTJModel(config=_UpperCamelCase					)
							lowerCAmelCase_      =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							lowerCAmelCase_      =     model(_UpperCamelCase					)

							lowerCAmelCase_      =     [input_ids, None, input_mask]  # None is the input for 'past'
							lowerCAmelCase_      =     model(_UpperCamelCase					)

							lowerCAmelCase_      =     model(_UpperCamelCase					)

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




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    *_UpperCamelCase					)    ->				Union[str, Any]:
							lowerCAmelCase_      =     TFGPTJModel(config=_UpperCamelCase					)

							# first forward pass
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    use_cache=_UpperCamelCase					)
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    token_type_ids=_UpperCamelCase					)
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    use_cache=_UpperCamelCase					)

							self.parent.assertTrue(len(_UpperCamelCase					) == len(_UpperCamelCase					)					)
							self.parent.assertTrue(len(_UpperCamelCase					) == len(_UpperCamelCase					) + 1					)

							lowerCAmelCase_     ,  lowerCAmelCase_      =     outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							lowerCAmelCase_      =     ids_tensor((self.batch_size, 1)    ,    config.vocab_size					)
							lowerCAmelCase_      =     ids_tensor([self.batch_size, 1]    ,    self.type_vocab_size					)

							# append to next input_ids and token_type_ids
							lowerCAmelCase_      =     tf.concat([input_ids, next_tokens]    ,    axis=-1					)
							lowerCAmelCase_      =     tf.concat([token_type_ids, next_token_types]    ,    axis=-1					)

							lowerCAmelCase_      =     model(_UpperCamelCase    ,    token_type_ids=_UpperCamelCase					)["last_hidden_state"]
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    past_key_values=_UpperCamelCase					)[
							    "last_hidden_state"
							]

							# select random slice
							lowerCAmelCase_      =     int(ids_tensor((1,)    ,    shape_list(_UpperCamelCase					)[-1]					)					)
							lowerCAmelCase_      =     output_from_no_past[:, -1, random_slice_idx]
							lowerCAmelCase_      =     output_from_past[:, 0, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(_UpperCamelCase    ,    _UpperCamelCase    ,    rtol=1e-6					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    *_UpperCamelCase					)    ->				Optional[int]:
							lowerCAmelCase_      =     TFGPTJModel(config=_UpperCamelCase					)

							# create attention mask
							lowerCAmelCase_      =     self.seq_length // 2
							lowerCAmelCase_      =     tf.ones((self.batch_size, half_seq_length)    ,    dtype=tf.intaa					)
							lowerCAmelCase_      =     tf.zeros((self.batch_size, self.seq_length - half_seq_length)    ,    dtype=tf.intaa					)
							lowerCAmelCase_      =     tf.concat([attn_mask_begin, attn_mask_end]    ,    axis=1					)

							# first forward pass
							lowerCAmelCase_     ,  lowerCAmelCase_      =     model(_UpperCamelCase    ,    attention_mask=_UpperCamelCase					).to_tuple()

							# create hypothetical next token and extent to next_input_ids
							lowerCAmelCase_      =     ids_tensor((self.batch_size, 1)    ,    config.vocab_size					)

							# change a random masked slice from input_ids
							lowerCAmelCase_      =     ids_tensor((1,)    ,    _UpperCamelCase					).numpy() + 1
							lowerCAmelCase_      =     ids_tensor((self.batch_size, self.seq_length)    ,    config.vocab_size					)
							lowerCAmelCase_      =     tf.range(self.seq_length					) == (self.seq_length - random_seq_idx_to_change)
							lowerCAmelCase_      =     tf.transpose(
							    tf.broadcast_to(tf.expand_dims(_UpperCamelCase    ,    -1					)    ,    (self.seq_length, self.batch_size)					)					)
							lowerCAmelCase_      =     tf.where(_UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)

							# append to next input_ids and attn_mask
							lowerCAmelCase_      =     tf.concat([input_ids, next_tokens]    ,    axis=-1					)
							lowerCAmelCase_      =     tf.concat([attn_mask, tf.ones((shape_list(_UpperCamelCase					)[0], 1)    ,    dtype=tf.intaa					)]    ,    axis=1					)

							# get two different outputs
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    attention_mask=_UpperCamelCase					)["last_hidden_state"]
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    past_key_values=_UpperCamelCase    ,    attention_mask=_UpperCamelCase					)[
							    "last_hidden_state"
							]

							# select random slice
							lowerCAmelCase_      =     int(ids_tensor((1,)    ,    shape_list(_UpperCamelCase					)[-1]					)					)
							lowerCAmelCase_      =     output_from_no_past[:, -1, random_slice_idx]
							lowerCAmelCase_      =     output_from_past[:, 0, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(_UpperCamelCase    ,    _UpperCamelCase    ,    rtol=1e-1_2					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    *_UpperCamelCase					)    ->				Optional[int]:
							lowerCAmelCase_      =     TFGPTJModel(config=_UpperCamelCase					)

							lowerCAmelCase_      =     input_ids[:1, :]
							lowerCAmelCase_      =     input_mask[:1, :]
							lowerCAmelCase_      =     token_type_ids[:1, :]
							lowerCAmelCase_      =     1

							# first forward pass
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    attention_mask=_UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    use_cache=_UpperCamelCase					)

							lowerCAmelCase_     ,  lowerCAmelCase_      =     outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							lowerCAmelCase_      =     ids_tensor((self.batch_size, 3)    ,    config.vocab_size					)
							lowerCAmelCase_      =     ids_tensor((self.batch_size, 3)    ,    2					)
							lowerCAmelCase_      =     ids_tensor((self.batch_size, 3)    ,    self.type_vocab_size					)

							# append to next input_ids and token_type_ids
							lowerCAmelCase_      =     tf.concat([input_ids, next_tokens]    ,    axis=-1					)
							lowerCAmelCase_      =     tf.concat([input_mask, next_attn_mask]    ,    axis=-1					)
							lowerCAmelCase_      =     tf.concat([token_type_ids, next_token_types]    ,    axis=-1					)

							lowerCAmelCase_      =     model(
							    _UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    attention_mask=_UpperCamelCase					)["last_hidden_state"]
							lowerCAmelCase_      =     model(
							    _UpperCamelCase    ,    token_type_ids=_UpperCamelCase    ,    attention_mask=_UpperCamelCase    ,    past_key_values=_UpperCamelCase    ,    )["last_hidden_state"]
							self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]					)

							# select random slice
							lowerCAmelCase_      =     int(ids_tensor((1,)    ,    shape_list(_UpperCamelCase					)[-1]					)					)
							lowerCAmelCase_      =     output_from_no_past[:, -3:, random_slice_idx]
							lowerCAmelCase_      =     output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(_UpperCamelCase    ,    _UpperCamelCase    ,    rtol=1e-3					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    *_UpperCamelCase					)    ->				List[str]:
							lowerCAmelCase_      =     TFGPTJForCausalLM(config=_UpperCamelCase					)
							lowerCAmelCase_      =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							lowerCAmelCase_      =     model(_UpperCamelCase					)
							self.parent.assertEqual(result.logits.shape    ,    (self.batch_size, self.seq_length, self.vocab_size)					)




				def 					__a						( self					)    ->				Tuple:
							lowerCAmelCase_      =     self.prepare_config_and_inputs()

							(
							    (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,  (
							    lowerCAmelCase_  
							)     ,    
							)      =     config_and_inputs

							lowerCAmelCase_      =     {
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							    "attention_mask": input_mask,
							}
							return config, inputs_dict





@require_tf
class      _lowerCAmelCase (     __a ,				__a ,				__a ,				unittest.TestCase	):
				_lowercase      		=(
				    (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
				    if is_tf_available()
				    else ()
				)

				_lowercase      		=(TFGPTJForCausalLM,) if is_tf_available() else ()
				_lowercase      		=(
				    {
				        '''feature-extraction''': TFGPTJModel,
				        '''question-answering''': TFGPTJForQuestionAnswering,
				        '''text-classification''': TFGPTJForSequenceClassification,
				        '''text-generation''': TFGPTJForCausalLM,
				        '''zero-shot''': TFGPTJForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				_lowercase      		=False
				_lowercase      		=False
				_lowercase      		=False
				_lowercase      		=False




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				Tuple:
							if (
							    pipeline_test_casse_name == "QAPipelineTests"
							    and tokenizer_name is not None
							    and not tokenizer_name.endswith("Fast"					)
							):
										# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
										# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
										# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
										return True

							return False




				def 					__a						( self					)    ->				Union[str, Any]:
							lowerCAmelCase_      =     TFGPTJModelTester(self					)
							lowerCAmelCase_      =     ConfigTester(self    ,    config_class=_UpperCamelCase    ,    n_embd=37					)




				def 					__a						( self					)    ->				Optional[Any]:
							self.config_tester.run_common_tests()




				def 					__a						( self					)    ->				Dict:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_gptj_model(*_UpperCamelCase					)




				def 					__a						( self					)    ->				Dict:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_gptj_model_past(*_UpperCamelCase					)




				def 					__a						( self					)    ->				List[str]:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_gptj_model_attention_mask_past(*_UpperCamelCase					)




				def 					__a						( self					)    ->				Dict:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_gptj_model_past_large_inputs(*_UpperCamelCase					)




				def 					__a						( self					)    ->				List[Any]:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_gptj_lm_head_model(*_UpperCamelCase					)




				@slow
				@unittest.skipIf(
				    not is_tf_available() or len(tf.config.list_physical_devices("GPU"					)					) > 0    ,    "skip testing on GPU for now to avoid GPU OOM."    ,    )
				def 					__a						( self					)    ->				Any:
							lowerCAmelCase_      =     TFGPTJModel.from_pretrained("EleutherAI/gpt-j-6B"    ,    from_pt=_UpperCamelCase					)
							self.assertIsNotNone(_UpperCamelCase					)




				@unittest.skip(reason="Currently, model embeddings are going to undergo a major refactor."					)
				def 					__a						( self					)    ->				int:
							super().test_resize_token_embeddings()





@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class      _lowerCAmelCase (     unittest.TestCase	):




				def 					__a						( self					)    ->				int:
							lowerCAmelCase_      =     TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B"    ,    from_pt=_UpperCamelCase					)
							lowerCAmelCase_      =     tf.convert_to_tensor([[464, 3_290]]    ,    dtype=tf.intaa					)  # The dog
							# fmt: off
							# The dog is a man's best friend. It is a loyal companion, and it is a friend
							lowerCAmelCase_      =     [464, 3_290, 318, 257, 582, 338, 1_266, 1_545, 13, 632, 318, 257, 9_112, 15_185, 11, 290, 340, 318, 257, 1_545]
							# fmt: on
							lowerCAmelCase_      =     model.generate(_UpperCamelCase    ,    do_sample=_UpperCamelCase					)
							self.assertListEqual(output_ids[0].numpy().tolist()    ,    _UpperCamelCase					)




				def 					__a						( self					)    ->				Tuple:
							lowerCAmelCase_      =     AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B"    ,    revision="float16"					)
							lowerCAmelCase_      =     TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B"    ,    revision="float16"    ,    from_pt=_UpperCamelCase					)

							lowerCAmelCase_      =     tokenizer("Today is a nice day and"    ,    return_tensors="tf"					)
							# forces the generation to happen on CPU, to avoid GPU-related quirks
							with tf.device(":/CPU:0"					):
										lowerCAmelCase_      =     model.generate(**_UpperCamelCase    ,    do_sample=_UpperCamelCase    ,    seed=[42, 0]					)
							lowerCAmelCase_      =     tokenizer.decode(output_ids[0]    ,    skip_special_tokens=_UpperCamelCase					)

							lowerCAmelCase_      =     "Today is a nice day and I’m going to go for a walk. I’"
							self.assertEqual(_UpperCamelCase    ,    _UpperCamelCase					)




				def 					__a						( self					)    ->				Tuple:
							lowerCAmelCase_      =     TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B"    ,    revision="float16"    ,    from_pt=_UpperCamelCase					)
							lowerCAmelCase_      =     AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B"    ,    revision="float16"					)

							lowerCAmelCase_      =     "left"

							# Define PAD Token = EOS Token = 50256
							lowerCAmelCase_      =     tokenizer.eos_token
							lowerCAmelCase_      =     model.config.eos_token_id

							# use different length sentences to test batching
							lowerCAmelCase_      =     [
							    "Hello, my dog is a little",
							    "Today, I",
							]
							lowerCAmelCase_      =     [
							    "Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia",
							    "Today, I’m going to be talking about a topic that’",
							]
							return model, tokenizer, sentences, expected_output_sentences




				def 					__a						( self					)    ->				int:
							# Confirms that we get the expected results with left-padded beam search
							lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     self._get_beam_search_test_objects()

							lowerCAmelCase_      =     tokenizer(_UpperCamelCase    ,    return_tensors="tf"    ,    padding=_UpperCamelCase					)
							lowerCAmelCase_      =     model.generate(**_UpperCamelCase    ,    do_sample=_UpperCamelCase    ,    num_beams=2					)
							lowerCAmelCase_      =     tokenizer.batch_decode(_UpperCamelCase    ,    skip_special_tokens=_UpperCamelCase					)
							self.assertListEqual(_UpperCamelCase    ,    _UpperCamelCase					)




				def 					__a						( self					)    ->				Tuple:
							# Confirms that left-padding is working properly
							lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     self._get_beam_search_test_objects()

							lowerCAmelCase_      =     tokenizer(_UpperCamelCase    ,    return_tensors="tf"    ,    padding=_UpperCamelCase					)
							lowerCAmelCase_      =     tokenizer(sentences[0]    ,    return_tensors="tf"					)
							lowerCAmelCase_      =     model.generate(**_UpperCamelCase    ,    do_sample=_UpperCamelCase    ,    num_beams=2					)
							lowerCAmelCase_      =     (
							    shape_list(inputs_non_padded["input_ids"]					)[-1]
							    - tf.reduce_sum(tf.cast(inputs["attention_mask"][-1]    ,    tf.intaa					)					).numpy()
							)
							lowerCAmelCase_      =     tokenizer(sentences[1]    ,    return_tensors="tf"					)
							lowerCAmelCase_      =     model.generate(
							    **_UpperCamelCase    ,    do_sample=_UpperCamelCase    ,    num_beams=2    ,    max_length=model.config.max_length - num_paddings					)
							lowerCAmelCase_      =     tokenizer.decode(output_non_padded[0]    ,    skip_special_tokens=_UpperCamelCase					)
							lowerCAmelCase_      =     tokenizer.decode(output_padded[0]    ,    skip_special_tokens=_UpperCamelCase					)
							self.assertListEqual(_UpperCamelCase    ,    [non_padded_sentence, padded_sentence]					)




				def 					__a						( self					)    ->				Any:
							# Confirms that XLA is working properly
							lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     self._get_beam_search_test_objects()

							lowerCAmelCase_      =     tokenizer(_UpperCamelCase    ,    return_tensors="tf"    ,    padding=_UpperCamelCase					)
							lowerCAmelCase_      =     tf.function(model.generate    ,    jit_compile=_UpperCamelCase					)
							lowerCAmelCase_      =     xla_generate(**_UpperCamelCase    ,    do_sample=_UpperCamelCase    ,    num_beams=2					)
							lowerCAmelCase_      =     tokenizer.batch_decode(_UpperCamelCase    ,    skip_special_tokens=_UpperCamelCase					)
							self.assertListEqual(_UpperCamelCase    ,    _UpperCamelCase					)





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


_A       =					{
    "configuration_xlm_prophetnet": ["XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMProphetNetConfig"],
}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A       =					["XLMProphetNetTokenizer"]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A       =					[
			    "XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "XLMProphetNetDecoder",
			    "XLMProphetNetEncoder",
			    "XLMProphetNetForCausalLM",
			    "XLMProphetNetForConditionalGeneration",
			    "XLMProphetNetModel",
			    "XLMProphetNetPreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_xlm_prophetnet import XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMProphetNetConfig

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_xlm_prophetnet import XLMProphetNetTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_xlm_prophetnet import (
						    XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
						    XLMProphetNetDecoder,
						    XLMProphetNetEncoder,
						    XLMProphetNetForCausalLM,
						    XLMProphetNetForConditionalGeneration,
						    XLMProphetNetModel,
						    XLMProphetNetPreTrainedModel,
						)

else:
			import sys

			_A       =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



