
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 			UpperCamelCase      :
     def __init__(     self  ,     snake_case__  ,     ):




       """simple docstring"""


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




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)

       _SCREAMING_SNAKE_CASE   :				List[Any]							    = None
       if self.use_labels:
         _SCREAMING_SNAKE_CASE   :				Optional[int]							    = ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)

       _SCREAMING_SNAKE_CASE   :				List[str]							    = 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 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       random.seed(self.seed				)
       tf.random.set_seed(self.seed				)
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = TFTransfoXLModel(UpperCamelCase__				)

       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				str							    = model(UpperCamelCase__				).to_tuple()

       _SCREAMING_SNAKE_CASE   :				List[str]							    = {"input_ids": input_ids_a, "mems": mems_a}

       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				int							    = 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 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = TFTransfoXLLMHeadModel(UpperCamelCase__				)

       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Optional[Any]							    = model(UpperCamelCase__				).to_tuple()

       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = {"input_ids": input_ids_a, "labels": lm_labels}
       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				List[str]							    = model(UpperCamelCase__				).to_tuple()

       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = model([input_ids_a, mems_a]				).to_tuple()

       _SCREAMING_SNAKE_CASE   :				Any							    = {"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}

       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				List[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 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple							    = TFTransfoXLForSequenceClassification(UpperCamelCase__				)
       _SCREAMING_SNAKE_CASE   :				str							    = model(UpperCamelCase__				)
       self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.num_labels)				)




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = self.prepare_config_and_inputs()
       ((_SCREAMING_SNAKE_CASE)    ,		(_SCREAMING_SNAKE_CASE)    ,		(_SCREAMING_SNAKE_CASE)    ,		(_SCREAMING_SNAKE_CASE))   :				Union[str, Any]							    = config_and_inputs
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = {"input_ids": input_ids_a}
       return config, inputs_dict
@require_tf
class 			UpperCamelCase      (							_A      ,       _A      ,       unittest.TestCase  ):
     A__      =			(
         (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
     )
     A__      =			() if is_tf_available() else ()
     A__      =			(
         {
             """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
     A__      =			False
     A__      =			False
     A__      =			False
     A__      =			False
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """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 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				int							    = TFTransfoXLModelTester(self				)
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = ConfigTester(self  ,     config_class=UpperCamelCase__  ,     d_embed=37				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       self.config_tester.run_common_tests()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       self.model_tester.set_seed()
       _SCREAMING_SNAKE_CASE   :				Tuple							    = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*UpperCamelCase__				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       self.model_tester.set_seed()
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*UpperCamelCase__				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[str]							    = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*UpperCamelCase__				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Optional[Any]							    = self.model_tester.prepare_config_and_inputs_for_common()
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = [TFTransfoXLForSequenceClassification]

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




       """simple docstring"""


       pass
     @slow
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _SCREAMING_SNAKE_CASE   :				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 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass
@require_tf
class 			UpperCamelCase      (							unittest.TestCase  ):
     @unittest.skip("Skip test until #12651 is resolved."				)
     @slow
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"				)
       # fmt: off
       _SCREAMING_SNAKE_CASE   :				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
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = [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>

       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = model.generate(UpperCamelCase__  ,     max_length=200  ,     do_sample=UpperCamelCase__				)
       self.assertListEqual(output_ids[0].numpy().tolist()  ,     UpperCamelCase__				)





"""simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


lowercase_       :						Tuple     					=	[
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]





def    _lowerCAmelCase    (     lowerCamelCase__							:							Dict,						lowerCamelCase__							:							int=None,						lowerCamelCase__							:							Any=None,						lowerCamelCase__							:							Any=None				)  ->    Tuple:
  _SCREAMING_SNAKE_CASE   :				List[Any]							    = True
  while ask_again:
    _SCREAMING_SNAKE_CASE   :				List[str]							    = input(lowerCamelCase__				)
    try:
      if default is not None and len(lowerCamelCase__				) == 0:
        return default
      return convert_value(lowerCamelCase__				) if convert_value is not None else result
    except Exception:
      if error_message is not None:
        print(lowerCamelCase__				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							Any,						lowerCamelCase__							:							Dict=[],						lowerCamelCase__							:							Optional[int]=None,						lowerCamelCase__							:							str=0				)  ->    str:
  _SCREAMING_SNAKE_CASE   :				int							    = BulletMenu(lowerCamelCase__,						lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				str							    = menu.run(default_choice=lowerCamelCase__				)
  return convert_value(lowerCamelCase__				) if convert_value is not None else result





def    _lowerCAmelCase    (     lowerCamelCase__							:							Optional[int]				)  ->    Optional[int]:
  _SCREAMING_SNAKE_CASE   :				str							    = int(lowerCamelCase__				)
  return ComputeEnvironment(["LOCAL_MACHINE", "AMAZON_SAGEMAKER"][value]				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							str				)  ->    List[Any]:
  _SCREAMING_SNAKE_CASE   :				str							    = int(lowerCamelCase__				)
  return DistributedType(["NO", "MULTI_CPU", "MULTI_XPU", "MULTI_GPU", "MULTI_NPU", "TPU"][value]				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							Optional[Any]				)  ->    List[Any]:
  _SCREAMING_SNAKE_CASE   :				List[Any]							    = int(lowerCamelCase__				)
  return DynamoBackend(DYNAMO_BACKENDS[value]				).value





def    _lowerCAmelCase    (     lowerCamelCase__							:							int				)  ->    Dict:
  _SCREAMING_SNAKE_CASE   :				int							    = int(lowerCamelCase__				)
  return PrecisionType(["no", "fp16", "bf16", "fp8"][value]				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							List[Any]				)  ->    Any:
  _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = int(lowerCamelCase__				)
  return SageMakerDistributedType(["NO", "DATA_PARALLEL", "MODEL_PARALLEL"][value]				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							List[Any]				)  ->    Optional[Any]:
  return {"yes": True, "no": False}[value.lower()]





class 			UpperCamelCase      (							argparse.RawDescriptionHelpFormatter  ):
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = super()._format_usage(snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Any							    = usage.replace("<command> [<args>] "  ,     ""				)
       return usage



