import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


UpperCAmelCase_           =				random.Random()




def    lowerCAmelCase_  (		lowercase:				str	,       lowercase:				Tuple=1.0	,       lowercase:				Dict=None	,       lowercase:				Optional[Any]=None		)     ->					Optional[int]:







 '''simple docstring'''
 if rng is None:
  _UpperCamelCase:  Union[str, Any]    						=			global_rng

 _UpperCamelCase:  str    						=			[]
 for batch_idx in range(shape[0]		):
  values.append([]		)
  for _ in range(shape[1]		):
   values[-1].append(rng.random() * scale		)

 return values




@require_torch
class 			__magic_name__	(		unittest.TestCase     ):





   """simple docstring"""




   def __init__(						self       :	Optional[Any]		,	_lowercase       :	str		,	_lowercase       :	Dict=7		,	_lowercase       :	Optional[int]=400		,	_lowercase       :	List[Any]=2_000		,	_lowercase       :	Tuple=1		,	_lowercase       :	Optional[Any]=0.0		,	_lowercase       :	Union[str, Any]=16_000		,	_lowercase       :	Tuple=True		,	_lowercase       :	Dict=80		,	_lowercase       :	List[str]=16		,	_lowercase       :	int=64		,	_lowercase       :	Optional[Any]="hann_window"		,	_lowercase       :	List[str]=80		,	_lowercase       :	Optional[int]=7_600		,	_lowercase       :	List[Any]=1E-10		,	_lowercase       :	Dict=True		,	):



    """simple docstring"""



    _UpperCamelCase:  List[Any]    						=			parent
    _UpperCamelCase:  Tuple    						=			batch_size
    _UpperCamelCase:  List[Any]    						=			min_seq_length
    _UpperCamelCase:  List[str]    						=			max_seq_length
    _UpperCamelCase:  Union[str, Any]    						=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
    _UpperCamelCase:  str    						=			feature_size
    _UpperCamelCase:  List[Any]    						=			padding_value
    _UpperCamelCase:  int    						=			sampling_rate
    _UpperCamelCase:  List[str]    						=			do_normalize
    _UpperCamelCase:  Any    						=			num_mel_bins
    _UpperCamelCase:  int    						=			hop_length
    _UpperCamelCase:  List[str]    						=			win_length
    _UpperCamelCase:  Any    						=			win_function
    _UpperCamelCase:  Tuple    						=			fmin
    _UpperCamelCase:  Union[str, Any]    						=			fmax
    _UpperCamelCase:  Tuple    						=			mel_floor
    _UpperCamelCase:  Tuple    						=			return_attention_mask



   def 	lowerCAmelCase    (						self       :	Dict				):



    """simple docstring"""



    return {
        "feature_size": self.feature_size,
        "padding_value": self.padding_value,
        "sampling_rate": self.sampling_rate,
        "do_normalize": self.do_normalize,
        "num_mel_bins": self.num_mel_bins,
        "hop_length": self.hop_length,
        "win_length": self.win_length,
        "win_function": self.win_function,
        "fmin": self.fmin,
        "fmax": self.fmax,
        "mel_floor": self.mel_floor,
        "return_attention_mask": self.return_attention_mask,
    }



   def 	lowerCAmelCase    (						self       :	Dict		,	_lowercase       :	List[str]=False		,	_lowercase       :	int=False				):



    """simple docstring"""



    def _flatten(_lowercase       :	Any				):
     return list(itertools.chain(*A_				)				)

    if equal_length:
     _UpperCamelCase:  List[str]    						=			floats_list((self.batch_size, self.max_seq_length)				)
    else:
     # make sure that inputs increase in size
     _UpperCamelCase:  Any    						=			[
         _flatten(floats_list((x, self.feature_size)				)				)
         for x in range(self.min_seq_length		,	self.max_seq_length		,	self.seq_length_diff				)
     ]

    if numpify:
     _UpperCamelCase:  Union[str, Any]    						=			[np.asarray(A_				) for x in speech_inputs]

    return speech_inputs



   def 	lowerCAmelCase    (						self       :	List[Any]		,	_lowercase       :	Union[str, Any]=False		,	_lowercase       :	Optional[Any]=False				):



    """simple docstring"""



    if equal_length:
     _UpperCamelCase:  int    						=			[floats_list((self.max_seq_length, self.num_mel_bins)				) for _ in range(self.batch_size				)]
    else:
     # make sure that inputs increase in size
     _UpperCamelCase:  Dict    						=			[
         floats_list((x, self.num_mel_bins)				)
         for x in range(self.min_seq_length		,	self.max_seq_length		,	self.seq_length_diff				)
     ]

    if numpify:
     _UpperCamelCase:  List[str]    						=			[np.asarray(A_				) for x in speech_inputs]

    return speech_inputs




@require_torch
class 			__magic_name__	(		__SCREAMING_SNAKE_CASE   ,						unittest.TestCase     ):





   """simple docstring"""




   lowerCAmelCase   :     Dict	      = SpeechTaFeatureExtractor



   def 	lowerCAmelCase    (						self       :	str				):



    """simple docstring"""



    _UpperCamelCase:  Dict    						=			SpeechTaFeatureExtractionTester(self				)



   def 	lowerCAmelCase    (						self       :	Optional[int]		,	_lowercase       :	int				):



    """simple docstring"""



    self.assertTrue(np.all(np.mean(A_		,	axis=0				) < 1E-3				)				)
    self.assertTrue(np.all(np.abs(np.var(A_		,	axis=0				) - 1				) < 1E-3				)				)



   def 	lowerCAmelCase    (						self       :	Optional[int]				):



    """simple docstring"""



    _UpperCamelCase:  Any    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    # create three inputs of length 800, 1000, and 1200
    _UpperCamelCase:  Optional[Any]    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]
    _UpperCamelCase:  str    						=			[np.asarray(A_				) for speech_input in speech_inputs]

    # Test not batched input
    _UpperCamelCase:  List[Any]    						=			feat_extract(speech_inputs[0]		,	return_tensors='''np'''				).input_values
    _UpperCamelCase:  Tuple    						=			feat_extract(np_speech_inputs[0]		,	return_tensors='''np'''				).input_values
    self.assertTrue(np.allclose(A_		,	A_		,	atol=1E-3				)				)

    # Test batched
    _UpperCamelCase:  Union[str, Any]    						=			feat_extract(A_		,	return_tensors='''np'''				).input_values
    _UpperCamelCase:  Any    						=			feat_extract(A_		,	return_tensors='''np'''				).input_values
    for enc_seq_a, enc_seq_a in zip(A_		,	A_				):
     self.assertTrue(np.allclose(A_		,	A_		,	atol=1E-3				)				)



   def 	lowerCAmelCase    (						self       :	List[str]				):



    """simple docstring"""



    _UpperCamelCase:  Tuple    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    _UpperCamelCase:  Optional[int]    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]

    _UpperCamelCase:  Optional[int]    						=			['''longest''', '''max_length''', '''do_not_pad''']
    _UpperCamelCase:  Tuple    						=			[None, 1_600, None]
    for max_length, padding in zip(A_		,	A_				):
     _UpperCamelCase:  Any    						=			feat_extract(A_		,	padding=A_		,	max_length=A_		,	return_tensors='''np'''				)
     _UpperCamelCase:  List[Any]    						=			processed.input_values

     self._check_zero_mean_unit_variance(input_values[0][:800]				)
     self.assertTrue(input_values[0][800:].sum() < 1E-6				)
     self._check_zero_mean_unit_variance(input_values[1][:1_000]				)
     self.assertTrue(input_values[0][1_000:].sum() < 1E-6				)
     self._check_zero_mean_unit_variance(input_values[2][:1_200]				)



   def 	lowerCAmelCase    (						self       :	Union[str, Any]				):



    """simple docstring"""



    _UpperCamelCase:  Optional[int]    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    _UpperCamelCase:  Optional[int]    						=			range(800		,	1_400		,	200				)
    _UpperCamelCase:  Union[str, Any]    						=			[floats_list((1, x)				)[0] for x in lengths]

    _UpperCamelCase:  Any    						=			['''longest''', '''max_length''', '''do_not_pad''']
    _UpperCamelCase:  Optional[Any]    						=			[None, 1_600, None]

    for max_length, padding in zip(A_		,	A_				):
     _UpperCamelCase:  List[Any]    						=			feat_extract(A_		,	max_length=A_		,	padding=A_				)
     _UpperCamelCase:  Any    						=			processed.input_values

     self._check_zero_mean_unit_variance(input_values[0][:800]				)
     self._check_zero_mean_unit_variance(input_values[1][:1_000]				)
     self._check_zero_mean_unit_variance(input_values[2][:1_200]				)



   def 	lowerCAmelCase    (						self       :	List[Any]				):



    """simple docstring"""



    _UpperCamelCase:  Tuple    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    _UpperCamelCase:  Dict    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]
    _UpperCamelCase:  Optional[Any]    						=			feat_extract(
        A_		,	truncation=A_		,	max_length=1_000		,	padding='''max_length'''		,	return_tensors='''np'''				)
    _UpperCamelCase:  List[str]    						=			processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]				)
    self._check_zero_mean_unit_variance(input_values[1]				)
    self._check_zero_mean_unit_variance(input_values[2]				)



   def 	lowerCAmelCase    (						self       :	str				):



    """simple docstring"""



    _UpperCamelCase:  Optional[Any]    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    _UpperCamelCase:  List[Any]    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]
    _UpperCamelCase:  Tuple    						=			feat_extract(
        A_		,	truncation=A_		,	max_length=1_000		,	padding='''longest'''		,	return_tensors='''np'''				)
    _UpperCamelCase:  Dict    						=			processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]				)
    self._check_zero_mean_unit_variance(input_values[1, :1_000]				)
    self._check_zero_mean_unit_variance(input_values[2]				)

    # make sure that if max_length < longest -> then pad to max_length
    self.assertTrue(input_values.shape == (3, 1_000)				)

    _UpperCamelCase:  Dict    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]
    _UpperCamelCase:  List[Any]    						=			feat_extract(
        A_		,	truncation=A_		,	max_length=2_000		,	padding='''longest'''		,	return_tensors='''np'''				)
    _UpperCamelCase:  Any    						=			processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]				)
    self._check_zero_mean_unit_variance(input_values[1, :1_000]				)
    self._check_zero_mean_unit_variance(input_values[2]				)

    # make sure that if max_length > longest -> then pad to longest
    self.assertTrue(input_values.shape == (3, 1_200)				)



   def 	lowerCAmelCase    (						self       :	Optional[int]				):



    """simple docstring"""



    _UpperCamelCase:  List[Any]    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    _UpperCamelCase:  Union[str, Any]    						=			np.random.rand(100				).astype(np.floataa				)
    _UpperCamelCase:  Union[str, Any]    						=			np_speech_inputs.tolist()

    for inputs in [py_speech_inputs, np_speech_inputs]:
     _UpperCamelCase:  str    						=			feature_extractor.pad([{'''input_values''': inputs}]		,	return_tensors='''np'''				)
     self.assertTrue(np_processed.input_values.dtype == np.floataa				)
     _UpperCamelCase:  int    						=			feature_extractor.pad([{'''input_values''': inputs}]		,	return_tensors='''pt'''				)
     self.assertTrue(pt_processed.input_values.dtype == torch.floataa				)



   def 	lowerCAmelCase    (						self       :	List[str]				):



    """simple docstring"""



    _UpperCamelCase:  Any    						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
    # create three inputs of length 800, 1000, and 1200
    _UpperCamelCase:  Tuple    						=			[floats_list((1, x)				)[0] for x in range(800		,	1_400		,	200				)]
    _UpperCamelCase:  Dict    						=			[np.asarray(A_				) for speech_input in speech_inputs]

    # Test feature size
    _UpperCamelCase:  Dict    						=			feature_extractor(audio_target=A_		,	padding=A_		,	return_tensors='''np'''				).input_values
    self.assertTrue(input_values.ndim == 3				)
    self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins				)

    # Test not batched input
    _UpperCamelCase:  Tuple    						=			feature_extractor(speech_inputs[0]		,	return_tensors='''np'''				).input_values
    _UpperCamelCase:  Optional[int]    						=			feature_extractor(np_speech_inputs[0]		,	return_tensors='''np'''				).input_values
    self.assertTrue(np.allclose(A_		,	A_		,	atol=1E-3				)				)

    # Test batched
    _UpperCamelCase:  Tuple    						=			feature_extractor(A_		,	return_tensors='''np'''				).input_values
    _UpperCamelCase:  Optional[int]    						=			feature_extractor(A_		,	return_tensors='''np'''				).input_values
    for enc_seq_a, enc_seq_a in zip(A_		,	A_				):
     self.assertTrue(np.allclose(A_		,	A_		,	atol=1E-3				)				)

    # Test 2-D numpy arrays are batched.
    _UpperCamelCase:  Optional[Any]    						=			[floats_list((1, x)				)[0] for x in (800, 800, 800)]
    _UpperCamelCase:  Optional[int]    						=			np.asarray(A_				)
    _UpperCamelCase:  Dict    						=			feature_extractor(A_		,	return_tensors='''np'''				).input_values
    _UpperCamelCase:  List[Any]    						=			feature_extractor(A_		,	return_tensors='''np'''				).input_values
    for enc_seq_a, enc_seq_a in zip(A_		,	A_				):
     self.assertTrue(np.allclose(A_		,	A_		,	atol=1E-3				)				)



   def 	lowerCAmelCase    (						self       :	Union[str, Any]				):



    """simple docstring"""



    _UpperCamelCase:  Union[str, Any]    						=			self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase:  int    						=			self.feature_extraction_class(**self.feat_extract_dict				)
    _UpperCamelCase:  Dict    						=			feat_extract.model_input_names[0]

    _UpperCamelCase:  int    						=			BatchFeature({input_name: speech_inputs}				)

    self.assertTrue(all(len(A_				) == len(A_				) for x, y in zip(A_		,	processed_features[input_name]				)				)				)

    _UpperCamelCase:  str    						=			self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_				)
    _UpperCamelCase:  Union[str, Any]    						=			BatchFeature({input_name: speech_inputs}		,	tensor_type='''np'''				)

    _UpperCamelCase:  List[Any]    						=			processed_features[input_name]

    if len(batch_features_input.shape				) < 3:
     _UpperCamelCase:  Dict    						=			batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.num_mel_bins)				)



   @require_torch
   def 	lowerCAmelCase    (						self       :	Optional[int]				):



    """simple docstring"""



    _UpperCamelCase:  int    						=			self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_				)
    _UpperCamelCase:  Optional[Any]    						=			self.feature_extraction_class(**self.feat_extract_dict				)
    _UpperCamelCase:  int    						=			feat_extract.model_input_names[0]

    _UpperCamelCase:  Union[str, Any]    						=			BatchFeature({input_name: speech_inputs}		,	tensor_type='''pt'''				)

    _UpperCamelCase:  Optional[Any]    						=			processed_features[input_name]

    if len(batch_features_input.shape				) < 3:
     _UpperCamelCase:  Any    						=			batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.num_mel_bins)				)



   @require_torch
   def 	lowerCAmelCase    (						self       :	Tuple				):



    """simple docstring"""



    _UpperCamelCase:  Dict    						=			self.feature_extraction_class(**self.feat_extract_dict				)
    _UpperCamelCase:  str    						=			self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase:  Union[str, Any]    						=			feat_extract.model_input_names[0]

    _UpperCamelCase:  List[Any]    						=			BatchFeature({input_name: speech_inputs}				)

    _UpperCamelCase:  Any    						=			feat_extract.num_mel_bins  # hack!

    _UpperCamelCase:  List[str]    						=			feat_extract.pad(A_		,	padding='''longest'''		,	return_tensors='''np'''				)[input_name]
    _UpperCamelCase:  Tuple    						=			feat_extract.pad(A_		,	padding='''longest'''		,	return_tensors='''pt'''				)[input_name]

    self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_pt.numpy().astype(np.floataa				).sum()				) < 1E-2				)



   def 	lowerCAmelCase    (						self       :	Optional[int]				):



    """simple docstring"""



    _UpperCamelCase:  Tuple    						=			self.feat_extract_dict
    _UpperCamelCase:  List[Any]    						=			True
    _UpperCamelCase:  Union[str, Any]    						=			self.feature_extraction_class(**A_				)
    _UpperCamelCase:  int    						=			self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase:  Union[str, Any]    						=			[len(A_				) for x in speech_inputs]
    _UpperCamelCase:  Tuple    						=			feat_extract.model_input_names[0]

    _UpperCamelCase:  Union[str, Any]    						=			BatchFeature({input_name: speech_inputs}				)

    _UpperCamelCase:  str    						=			feat_extract.num_mel_bins  # hack!

    _UpperCamelCase:  Optional[Any]    						=			feat_extract.pad(A_		,	padding='''longest'''		,	return_tensors='''np'''				)
    self.assertIn('''attention_mask'''		,	A_				)
    self.assertListEqual(list(processed.attention_mask.shape				)		,	list(processed[input_name].shape[:2]				)				)
    self.assertListEqual(processed.attention_mask.sum(-1				).tolist()		,	A_				)



   def 	lowerCAmelCase    (						self       :	str				):



    """simple docstring"""



    _UpperCamelCase:  Optional[Any]    						=			self.feat_extract_dict
    _UpperCamelCase:  List[Any]    						=			True
    _UpperCamelCase:  Dict    						=			self.feature_extraction_class(**A_				)
    _UpperCamelCase:  List[str]    						=			self.feat_extract_tester.prepare_inputs_for_target()
    _UpperCamelCase:  List[str]    						=			[len(A_				) for x in speech_inputs]
    _UpperCamelCase:  str    						=			feat_extract.model_input_names[0]

    _UpperCamelCase:  Any    						=			BatchFeature({input_name: speech_inputs}				)
    _UpperCamelCase:  List[str]    						=			min(A_				)

    _UpperCamelCase:  Any    						=			feat_extract.num_mel_bins  # hack!

    _UpperCamelCase:  List[str]    						=			feat_extract.pad(
        A_		,	padding='''max_length'''		,	max_length=A_		,	truncation=A_		,	return_tensors='''np'''				)
    self.assertIn('''attention_mask'''		,	A_				)
    self.assertListEqual(
        list(processed_pad.attention_mask.shape				)		,	[processed_pad[input_name].shape[0], max_length]				)
    self.assertListEqual(
        processed_pad.attention_mask[:, :max_length].sum(-1				).tolist()		,	[max_length for x in speech_inputs]				)



   def 	lowerCAmelCase    (						self       :	List[Any]		,	_lowercase       :	Tuple				):



    """simple docstring"""



    from datasets import load_dataset

    _UpperCamelCase:  List[Any]    						=			load_dataset('''hf-internal-testing/librispeech_asr_dummy'''		,	'''clean'''		,	split='''validation'''				)
    # automatic decoding with librispeech
    _UpperCamelCase:  Dict    						=			ds.sort('''id'''				).select(range(A_				)				)[:num_samples]['''audio''']

    return [x["array"] for x in speech_samples]



   def 	lowerCAmelCase    (						self       :	Union[str, Any]				):



    """simple docstring"""



    _UpperCamelCase:  List[str]    						=			torch.tensor(
        [2.38_04E-03, 2.07_52E-03, 1.98_36E-03, 2.10_57E-03, 1.61_74E-03,
         3.05_18E-04, 9.15_53E-05, 3.35_69E-04, 9.76_56E-04, 1.83_11E-03,
         2.01_42E-03, 2.10_57E-03, 1.73_95E-03, 4.57_76E-04, -3.96_73E-04,
         4.57_76E-04, 1.00_71E-03, 9.15_53E-05, 4.88_28E-04, 1.15_97E-03,
         7.32_42E-04, 9.46_04E-04, 1.80_05E-03, 1.83_11E-03, 8.85_01E-04,
         4.27_25E-04, 4.88_28E-04, 7.32_42E-04, 1.09_86E-03, 2.10_57E-03]				)
    # fmt: on

    _UpperCamelCase:  Any    						=			self._load_datasamples(1				)
    _UpperCamelCase:  Union[str, Any]    						=			SpeechTaFeatureExtractor()
    _UpperCamelCase:  str    						=			feature_extractor(A_		,	return_tensors='''pt'''				).input_values
    self.assertEquals(input_values.shape		,	(1, 93_680)				)
    self.assertTrue(torch.allclose(input_values[0, :30]		,	A_		,	atol=1E-6				)				)



   def 	lowerCAmelCase    (						self       :	Tuple				):



    """simple docstring"""



    _UpperCamelCase:  Union[str, Any]    						=			torch.tensor(
        [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
         -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
         -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
         -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]				)
    # fmt: on

    _UpperCamelCase:  Any    						=			self._load_datasamples(1				)
    _UpperCamelCase:  List[Any]    						=			SpeechTaFeatureExtractor()
    _UpperCamelCase:  str    						=			feature_extractor(audio_target=A_		,	return_tensors='''pt'''				).input_values
    self.assertEquals(input_values.shape		,	(1, 366, 80)				)
    self.assertTrue(torch.allclose(input_values[0, 0, :30]		,	A_		,	atol=1E-4				)				)






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 					__snake_case	:


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			parent
        SCREAMING_SNAKE_CASE__											=			13
        SCREAMING_SNAKE_CASE__											=			7
        SCREAMING_SNAKE_CASE__											=			30
        SCREAMING_SNAKE_CASE__											=			self.seq_length + self.mem_len
        SCREAMING_SNAKE_CASE__											=			15
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			99
        SCREAMING_SNAKE_CASE__											=			[10, 50, 80]
        SCREAMING_SNAKE_CASE__											=			32
        SCREAMING_SNAKE_CASE__											=			32
        SCREAMING_SNAKE_CASE__											=			4
        SCREAMING_SNAKE_CASE__											=			8
        SCREAMING_SNAKE_CASE__											=			1_28
        SCREAMING_SNAKE_CASE__											=			2
        SCREAMING_SNAKE_CASE__											=			2
        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			1
        SCREAMING_SNAKE_CASE__											=			0
        SCREAMING_SNAKE_CASE__											=			3
        SCREAMING_SNAKE_CASE__											=			self.vocab_size - 1
        SCREAMING_SNAKE_CASE__											=			0.01



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )
        SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

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

        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self     ):





        '''simple docstring'''

        random.seed(self.seed     )
        tf.random.set_seed(self.seed     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLModel(A_     )

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a, '''mems''': mems_a}

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLLMHeadModel(A_     )

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a, '''labels''': lm_labels}
        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model([input_ids_a, mems_a]     ).to_tuple()

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

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLForSequenceClassification(A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_     )
        self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_labels)     )




    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.prepare_config_and_inputs()
        ((SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__))											=			config_and_inputs
        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a}
        return config, inputs_dict





@require_tf
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







    lowerCamelCase__    :		Optional[int]				=	(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    lowerCamelCase__    :		List[str]				=	() if is_tf_available() else ()
    lowerCamelCase__    :		List[Any]				=	(
        {
            """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__    :		Tuple				=	False
    lowerCamelCase__    :		Any				=	False
    lowerCamelCase__    :		Dict				=	False
    lowerCamelCase__    :		Optional[Any]				=	False



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''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  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLModelTester(self     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_   ,				d_embed=37     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.model_tester.set_seed()
        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_model(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.model_tester.set_seed()
        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_lm_head(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE__											=			[TFTransfoXLForSequenceClassification]

        for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__											=			model_class(A_     )
            assert isinstance(model.get_input_embeddings()   ,				tf.keras.layers.Layer     )
            if model_class in list_other_models_with_output_ebd:
                SCREAMING_SNAKE_CASE__											=			model.get_output_embeddings()
                assert isinstance(A_   ,				tf.keras.layers.Layer     )
                SCREAMING_SNAKE_CASE__											=			model.get_bias()
                assert name is None
            else:
                SCREAMING_SNAKE_CASE__											=			model.get_output_embeddings()
                assert x is None
                SCREAMING_SNAKE_CASE__											=			model.get_bias()
                assert name is None



    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass



    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__											=			TFTransfoXLModel.from_pretrained(A_     )
            self.assertIsNotNone(A_     )




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





        '''simple docstring'''

        pass





@require_tf
class 					__snake_case	(  unittest.TestCase    ):


    '''simple docstring'''







    @unittest.skip('''Skip test until #12651 is resolved.'''     )
    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''     )
        # fmt: off
        SCREAMING_SNAKE_CASE__											=			tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,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
        SCREAMING_SNAKE_CASE__											=			[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,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>

        SCREAMING_SNAKE_CASE__											=			model.generate(A_   ,				max_length=2_00   ,				do_sample=A_     )
        self.assertListEqual(output_ids[0].numpy().tolist()   ,				A_     )
