

'''simple docstring'''





import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
							import PIL.Image

							from .features import FeatureType


UpperCamelCase_    						=       None
UpperCamelCase_    						=       """<""" if sys.byteorder == """little""" else """>"""
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
UpperCamelCase_    						=       [
    np.dtype("""|b1"""),
    np.dtype("""|u1"""),
    np.dtype("""<u2"""),
    np.dtype(""">u2"""),
    np.dtype("""<i2"""),
    np.dtype(""">i2"""),
    np.dtype("""<u4"""),
    np.dtype(""">u4"""),
    np.dtype("""<i4"""),
    np.dtype(""">i4"""),
    np.dtype("""<f4"""),
    np.dtype(""">f4"""),
    np.dtype("""<f8"""),
    np.dtype(""">f8"""),
]





@dataclass
class 		__SCREAMING_SNAKE_CASE							:
				lowerCamelCase_		       =    True
				lowerCamelCase_		       =    None
				# Automatically constructed
				lowerCamelCase_		       =    "PIL.Image.Image"
				lowerCamelCase_		       =    pa.struct({'bytes': pa.binary(), 'path': pa.string()}      )
				lowerCamelCase_		       =    field(default='Image'						,							init=lowercase__						,							repr=lowercase__      )







				def __call__(       self     :		str   ):
										'''simple docstring'''
										return self.pa_type







				def  lowerCamelCase_	(       self     :		List[str]		,					UpperCAmelCase__     :		Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"]   ):
										'''simple docstring'''
										if config.PIL_AVAILABLE:
																import PIL.Image
										else:
																raise ImportError('''To support encoding images, please install \'Pillow\'.'''   )

										if isinstance(UpperCAmelCase__		,					UpperCAmelCase__   ):
																lowercase :							Tuple    		=np.array(UpperCAmelCase__   )

										if isinstance(UpperCAmelCase__		,					UpperCAmelCase__   ):
																return {"path": value, "bytes": None}
										elif isinstance(UpperCAmelCase__		,					UpperCAmelCase__   ):
																return {"path": None, "bytes": value}
										elif isinstance(UpperCAmelCase__		,					np.ndarray   ):
																# convert the image array to PNG/TIFF bytes
																return encode_np_array(UpperCAmelCase__   )
										elif isinstance(UpperCAmelCase__		,					PIL.Image.Image   ):
																# convert the PIL image to bytes (default format is PNG/TIFF)
																return encode_pil_image(UpperCAmelCase__   )
										elif value.get('''path'''   ) is not None and os.path.isfile(value['''path''']   ):
																# we set "bytes": None to not duplicate the data if they're already available locally
																return {"bytes": None, "path": value.get('''path'''   )}
										elif value.get('''bytes'''   ) is not None or value.get('''path'''   ) is not None:
																# store the image bytes, and path is used to infer the image format using the file extension
																return {"bytes": value.get('''bytes'''   ), "path": value.get('''path'''   )}
										else:
																raise ValueError(
																    F'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.'''   )







				def  lowerCamelCase_	(       self     :		List[str]		,					UpperCAmelCase__     :		dict		,					UpperCAmelCase__     :		Optional[int]=None   ):
										'''simple docstring'''
										if not self.decode:
																raise RuntimeError('''Decoding is disabled for this feature. Please use Image(decode=True) instead.'''   )

										if config.PIL_AVAILABLE:
																import PIL.Image
										else:
																raise ImportError('''To support decoding images, please install \'Pillow\'.'''   )

										if token_per_repo_id is None:
																lowercase :							Tuple    		={}

										lowercase		,	lowercase :							List[Any]    		=value['''path'''], value['''bytes''']
										if bytes_ is None:
																if path is None:
																						raise ValueError(F'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.'''   )
																else:
																						if is_local_path(UpperCAmelCase__   ):
																												lowercase :							int    		=PIL.Image.open(UpperCAmelCase__   )
																						else:
																												lowercase :							Optional[Any]    		=path.split('''::'''   )[-1]
																												try:
																																		lowercase :							Any    		=string_to_dict(UpperCAmelCase__		,					config.HUB_DATASETS_URL   )['''repo_id''']
																																		lowercase :							Union[str, Any]    		=token_per_repo_id.get(UpperCAmelCase__   )
																												except ValueError:
																																		lowercase :							Any    		=None
																												with xopen(UpperCAmelCase__		,					'''rb'''		,					use_auth_token=UpperCAmelCase__   ) as f:
																																		lowercase :							int    		=BytesIO(f.read()   )
																												lowercase :							int    		=PIL.Image.open(bytes_   )
										else:
																lowercase :							List[Any]    		=PIL.Image.open(BytesIO(bytes_   )   )
										image.load()  # to avoid "Too many open files" errors
										return image







				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										from .features import Value

										return (
										    self
										    if self.decode
										    else {
										        "bytes": Value('''binary'''   ),
										        "path": Value('''string'''   ),
										    }
										)







				def  lowerCamelCase_	(       self     :		Tuple		,					UpperCAmelCase__     :		Union[pa.StringArray, pa.StructArray, pa.ListArray]   ):
										'''simple docstring'''
										if pa.types.is_string(storage.type   ):
																lowercase :							str    		=pa.array([None] * len(UpperCAmelCase__   )		,					type=pa.binary()   )
																lowercase :							str    		=pa.StructArray.from_arrays([bytes_array, storage]		,					['''bytes''', '''path''']		,					mask=storage.is_null()   )
										elif pa.types.is_binary(storage.type   ):
																lowercase :							int    		=pa.array([None] * len(UpperCAmelCase__   )		,					type=pa.string()   )
																lowercase :							Union[str, Any]    		=pa.StructArray.from_arrays([storage, path_array]		,					['''bytes''', '''path''']		,					mask=storage.is_null()   )
										elif pa.types.is_struct(storage.type   ):
																if storage.type.get_field_index('''bytes'''   ) >= 0:
																						lowercase :							Union[str, Any]    		=storage.field('''bytes'''   )
																else:
																						lowercase :							Dict    		=pa.array([None] * len(UpperCAmelCase__   )		,					type=pa.binary()   )
																if storage.type.get_field_index('''path'''   ) >= 0:
																						lowercase :							Union[str, Any]    		=storage.field('''path'''   )
																else:
																						lowercase :							List[str]    		=pa.array([None] * len(UpperCAmelCase__   )		,					type=pa.string()   )
																lowercase :							Optional[Any]    		=pa.StructArray.from_arrays([bytes_array, path_array]		,					['''bytes''', '''path''']		,					mask=storage.is_null()   )
										elif pa.types.is_list(storage.type   ):
																lowercase :							Optional[Any]    		=pa.array(
																    [encode_np_array(np.array(UpperCAmelCase__   )   )['''bytes'''] if arr is not None else None for arr in storage.to_pylist()]		,					type=pa.binary()		,					)
																lowercase :							int    		=pa.array([None] * len(UpperCAmelCase__   )		,					type=pa.string()   )
																lowercase :							List[str]    		=pa.StructArray.from_arrays(
																    [bytes_array, path_array]		,					['''bytes''', '''path''']		,					mask=bytes_array.is_null()   )
										return array_cast(UpperCAmelCase__		,					self.pa_type   )







				def  lowerCamelCase_	(       self     :		Optional[int]		,					UpperCAmelCase__     :		pa.StructArray   ):
										'''simple docstring'''

										@no_op_if_value_is_null
										def path_to_bytes(UpperCAmelCase__     :		Optional[int]   ):
																with xopen(UpperCAmelCase__		,					'''rb'''   ) as f:
																						lowercase :							Union[str, Any]    		=f.read()
																return bytes_

										lowercase :							Optional[Any]    		=pa.array(
										    [
										        (path_to_bytes(x['''path''']   ) if x['''bytes'''] is None else x['''bytes''']) if x is not None else None
										        for x in storage.to_pylist()
										    ]		,					type=pa.binary()		,					)
										lowercase :							List[Any]    		=pa.array(
										    [os.path.basename(UpperCAmelCase__   ) if path is not None else None for path in storage.field('''path'''   ).to_pylist()]		,					type=pa.string()		,					)
										lowercase :							str    		=pa.StructArray.from_arrays([bytes_array, path_array]		,					['''bytes''', '''path''']		,					mask=bytes_array.is_null()   )
										return array_cast(UpperCAmelCase__		,					self.pa_type   )






def 				_lowerCAmelCase			(   )				->  List[str]:
						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError('''To support encoding images, please install \'Pillow\'.'''						)

						global _IMAGE_COMPRESSION_FORMATS
						if _IMAGE_COMPRESSION_FORMATS is None:
												PIL.Image.init()
												lowercase :							List[Any]    		=list(set(PIL.Image.OPEN.keys()						) & set(PIL.Image.SAVE.keys()						)						)
						return _IMAGE_COMPRESSION_FORMATS






def 				_lowerCAmelCase			(   __magic_name__						:     "PIL.Image.Image"						)				->  bytes:
						lowercase :							int    		=BytesIO()
						if image.format in list_image_compression_formats():
												lowercase :							Any    		=image.format
						else:
												lowercase :							Optional[Any]    		='''PNG''' if image.mode in ['''1''', '''L''', '''LA''', '''RGB''', '''RGBA'''] else '''TIFF'''
						image.save(__magic_name__   , format=__magic_name__						)
						return buffer.getvalue()






def 				_lowerCAmelCase			(   __magic_name__						:     "PIL.Image.Image"						)				->  dict:
						if hasattr(__magic_name__   , '''filename'''						) and image.filename != "":
												return {"path": image.filename, "bytes": None}
						else:
												return {"path": None, "bytes": image_to_bytes(__magic_name__						)}






def 				_lowerCAmelCase			(   __magic_name__						:     np.ndarray						)				->  dict:
						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError('''To support encoding images, please install \'Pillow\'.'''						)

						lowercase :							Optional[int]    		=array.dtype
						lowercase :							Dict    		=dtype.byteorder if dtype.byteorder != '''=''' else _NATIVE_BYTEORDER
						lowercase :							Dict    		=dtype.kind
						lowercase :							int    		=dtype.itemsize

						lowercase :							int    		=None

						# Multi-channel array case (only np.dtype("|u1") is allowed)
						if array.shape[2:]:
												lowercase :							Any    		=np.dtype('''|u1'''						)
												if dtype_kind not in ["u", "i"]:
																		raise TypeError(
																		    f'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.'''						)
												if dtype is not dest_dtype:
																		warnings.warn(f'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''						)
    # Exact match
						elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
												lowercase :							str    		=dtype
						else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
												while dtype_itemsize >= 1:
																		lowercase :							Optional[Any]    		=dtype_byteorder + dtype_kind + str(__magic_name__						)
																		lowercase :							Union[str, Any]    		=np.dtype(__magic_name__						)
																		if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
																								warnings.warn(f'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''						)
																								break
																		else:
																								dtype_itemsize //= 2

						if dest_dtype is None:
												raise TypeError(
												    f'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}'''						)
						lowercase :							Dict    		=PIL.Image.fromarray(array.astype(__magic_name__						)						)
						return {"path": None, "bytes": image_to_bytes(__magic_name__						)}







def 				_lowerCAmelCase			(   __magic_name__						:     Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]						)				->  List[dict]:
						if config.PIL_AVAILABLE:
												import PIL.Image
						else:
												raise ImportError('''To support encoding images, please install \'Pillow\'.'''						)

						if objs:
												lowercase		,	lowercase :							Tuple    		=first_non_null_value(__magic_name__						)
												if isinstance(__magic_name__   , __magic_name__						):
																		return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
												if isinstance(__magic_name__   , np.ndarray						):
																		lowercase :							Optional[int]    		=no_op_if_value_is_null(__magic_name__						)
																		return [obj_to_image_dict_func(__magic_name__						) for obj in objs]
												elif isinstance(__magic_name__   , PIL.Image.Image						):
																		lowercase :							Optional[int]    		=no_op_if_value_is_null(__magic_name__						)
																		return [obj_to_image_dict_func(__magic_name__						) for obj in objs]
												else:
																		return objs
						else:
												return objs








'''simple docstring'''





from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFTransfoXLForSequenceClassification,
							    TFTransfoXLLMHeadModel,
							    TFTransfoXLModel,
							)





class 		__SCREAMING_SNAKE_CASE							:







				def __init__(       self     :		List[str]		,					UpperCAmelCase__     :		Dict		,					):
										'''simple docstring'''
										lowercase :							Any    		=parent
										lowercase :							Optional[int]    		=13
										lowercase :							Union[str, Any]    		=7
										lowercase :							str    		=30
										lowercase :							Optional[int]    		=self.seq_length + self.mem_len
										lowercase :							Dict    		=15
										lowercase :							List[str]    		=True
										lowercase :							Optional[int]    		=True
										lowercase :							Tuple    		=99
										lowercase :							str    		=[10, 50, 80]
										lowercase :							List[Any]    		=32
										lowercase :							Optional[int]    		=32
										lowercase :							int    		=4
										lowercase :							Any    		=8
										lowercase :							List[Any]    		=128
										lowercase :							List[str]    		=2
										lowercase :							Tuple    		=2
										lowercase :							int    		=None
										lowercase :							Optional[int]    		=1
										lowercase :							int    		=0
										lowercase :							List[str]    		=3
										lowercase :							str    		=self.vocab_size - 1
										lowercase :							Tuple    		=0.01







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							str    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )
										lowercase :							Tuple    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )

										lowercase :							str    		=None
										if self.use_labels:
																lowercase :							Tuple    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )

										lowercase :							Union[str, Any]    		=TransfoXLConfig(
										    vocab_size=self.vocab_size		,					mem_len=self.mem_len		,					clamp_len=self.clamp_len		,					cutoffs=self.cutoffs		,					d_model=self.hidden_size		,					d_embed=self.d_embed		,					n_head=self.num_attention_heads		,					d_head=self.d_head		,					d_inner=self.d_inner		,					div_val=self.div_val		,					n_layer=self.num_hidden_layers		,					eos_token_id=self.eos_token_id		,					pad_token_id=self.vocab_size - 1		,					init_range=self.init_range		,					num_labels=self.num_labels		,					)

										return (config, input_ids_a, input_ids_a, lm_labels)







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										random.seed(self.seed   )
										tf.random.set_seed(self.seed   )







				def  lowerCamelCase_	(       self     :		Union[str, Any]		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		List[str]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=TFTransfoXLModel(UpperCAmelCase__   )

										lowercase		,	lowercase :							Optional[Any]    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase :							List[str]    		={'''input_ids''': input_ids_a, '''mems''': mems_a}

										lowercase		,	lowercase :							Any    		=model(UpperCAmelCase__   ).to_tuple()

										self.parent.assertEqual(hidden_states_a.shape		,					(self.batch_size, self.seq_length, self.hidden_size)   )
										self.parent.assertEqual(hidden_states_a.shape		,					(self.batch_size, self.seq_length, self.hidden_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)







				def  lowerCamelCase_	(       self     :		int		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										lowercase :							int    		=TFTransfoXLLMHeadModel(UpperCAmelCase__   )

										lowercase		,	lowercase :							Tuple    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase :							Optional[Any]    		={'''input_ids''': input_ids_a, '''labels''': lm_labels}
										lowercase		,	lowercase :							Optional[int]    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase		,	lowercase :							List[str]    		=model([input_ids_a, mems_a]   ).to_tuple()

										lowercase :							int    		={'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

										lowercase		,	lowercase :							str    		=model(UpperCAmelCase__   ).to_tuple()

										self.parent.assertEqual(lm_logits_a.shape		,					(self.batch_size, self.seq_length, self.vocab_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)

										self.parent.assertEqual(lm_logits_a.shape		,					(self.batch_size, self.seq_length, self.vocab_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)







				def  lowerCamelCase_	(       self     :		str		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		=TFTransfoXLForSequenceClassification(UpperCAmelCase__   )
										lowercase :							Union[str, Any]    		=model(UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase :							List[Any]    		=self.prepare_config_and_inputs()
										((lowercase)		,	(lowercase)		,	(lowercase)		,	(lowercase)) :							Optional[Any]    		=config_and_inputs
										lowercase :							Union[str, Any]    		={'''input_ids''': input_ids_a}
										return config, inputs_dict





@require_tf
class 		__SCREAMING_SNAKE_CASE							(			lowercase__						,							lowercase__						,							unittest.TestCase      ):
				lowerCamelCase_		       =    (
				    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
				)
				lowerCamelCase_		       =    () if is_tf_available() else ()
				lowerCamelCase_		       =    (
				    {
				        'feature-extraction': TFTransfoXLModel,
				        'text-classification': TFTransfoXLForSequenceClassification,
				        'text-generation': TFTransfoXLLMHeadModel,
				        'zero-shot': TFTransfoXLForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False







				def  lowerCamelCase_	(       self     :		Dict		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										if pipeline_test_casse_name == "TextGenerationPipelineTests":
																# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
																# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
																# tokenizer.
																return True

										return False







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							Any    		=TFTransfoXLModelTester(self   )
										lowercase :							Optional[int]    		=ConfigTester(self		,					config_class=UpperCAmelCase__		,					d_embed=37   )







				def  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										self.config_tester.run_common_tests()







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										self.model_tester.set_seed()
										lowercase :							List[str]    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_model(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										self.model_tester.set_seed()
										lowercase :							Any    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_lm_head(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							Dict    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase		,	lowercase :							Tuple    		=self.model_tester.prepare_config_and_inputs_for_common()
										lowercase :							int    		=[TFTransfoXLForSequenceClassification]

										for model_class in self.all_model_classes:
																lowercase :							str    		=model_class(UpperCAmelCase__   )
																assert isinstance(model.get_input_embeddings()		,					tf.keras.layers.Layer   )
																if model_class in list_other_models_with_output_ebd:
																						lowercase :							Union[str, Any]    		=model.get_output_embeddings()
																						assert isinstance(UpperCAmelCase__		,					tf.keras.layers.Layer   )
																						lowercase :							Any    		=model.get_bias()
																						assert name is None
																else:
																						lowercase :							Optional[int]    		=model.get_output_embeddings()
																						assert x is None
																						lowercase :							Optional[int]    		=model.get_bias()
																						assert name is None







				def  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										# TODO JP: Make TransfoXL XLA compliant
										pass







				@slow
				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase :							int    		=TFTransfoXLModel.from_pretrained(UpperCAmelCase__   )
																self.assertIsNotNone(UpperCAmelCase__   )







				@unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''   )
				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										pass





@require_tf
class 		__SCREAMING_SNAKE_CASE							(			unittest.TestCase      ):







				@unittest.skip('''Skip test until #12651 is resolved.'''   )
				@slow
				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''   )
										# fmt: off
										lowercase :							Tuple    		=tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0]]		,					dtype=tf.intaa   )  # noqa: E231
										# fmt: on
										#  In 1991 , the remains of Russian Tsar Nicholas II and his family
										#  ( except for Alexei and Maria ) are discovered .
										#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
										#  remainder of the story . 1883 Western Siberia ,
										#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
										#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
										#  father initially slaps him for making such an accusation , Rasputin watches as the
										#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
										#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
										#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

										# fmt: off
										lowercase :							Optional[int]    		=[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0,33,1,1857,2,1,1009,4,1109,11739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,0]  # noqa: E231
										# fmt: on
										#  In 1991, the remains of Russian Tsar Nicholas II and his family (
										#  except for Alexei and Maria ) are discovered. The voice of young son,
										#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
										#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
										#  and a group of men to perform magic. Rasputin has a vision and
										#  denounces one of the men as a horse thief. Although his father initially
										#  slaps him for making such an accusation, Rasputin watches as the man
										#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
										#  of the Virgin Mary, prompting him to become a priest.
										#  Rasputin quickly becomes famous, with people, even a bishop, begging for
										#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
										# Nicholas II and his family were discovered. The voice of <unk> young son,
										# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

										lowercase :							int    		=model.generate(UpperCAmelCase__		,					max_length=200		,					do_sample=UpperCAmelCase__   )
										self.assertListEqual(output_ids[0].numpy().tolist()		,					UpperCAmelCase__   )





