


import collections
import importlib.util
import os
import re
from pathlib import Path


snake_case    :   List[str]	    =					"""src/transformers"""


# Matches is_xxx_available()
snake_case    :   Optional[int]	    =					re.compile(R'''is\_([a-z_]*)_available()''')
# Catches a one-line _import_struct = {xxx}
snake_case    :   Any	    =					re.compile(R'''^_import_structure\s+=\s+\{([^\}]+)\}''')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
snake_case    :   str	    =					re.compile(R'''\s+\"\S*\":\s+\[([^\]]*)\]''')
# Catches a line if not is_foo_available
snake_case    :   str	    =					re.compile(R'''^\s*if\s+not\s+is\_[a-z_]*\_available\(\)''')
# Catches a line _import_struct["bla"].append("foo")
snake_case    :   Tuple	    =					re.compile(R'''^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)''')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
snake_case    :   Any	    =					re.compile(R'''^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]''')
# Catches a line with an object between quotes and a comma:     "MyModel",
snake_case    :   Optional[Any]	    =					re.compile('''^\s+\"([^\"]+)\",''')
# Catches a line with objects between brackets only:    ["foo", "bar"],
snake_case    :   Optional[Any]	    =					re.compile('''^\s+\[([^\]]+)\]''')
# Catches a line with from foo import bar, bla, boo
snake_case    :   Tuple	    =					re.compile(R'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
# Catches a line with try:
snake_case    :   Optional[int]	    =					re.compile(R'''^\s*try:''')
# Catches a line with else:
snake_case    :   List[str]	    =					re.compile(R'''^\s*else:''')
def     __lowerCamelCase						(			UpperCAmelCase_						:		Dict						):




      """simple docstring"""





      if _re_test_backend.search(lowerCAmelCase__						) is None:
            return None
      a						:List[Any]										=	[b[0] for b in _re_backend.findall(lowerCAmelCase__						)]
      backends.sort()
      return "_and_".join(lowerCAmelCase__						)
def     __lowerCamelCase						(			UpperCAmelCase_						:		Tuple						):




      """simple docstring"""





      with open(lowerCAmelCase__			,  '''r'''			,  encoding='''utf-8'''			,  newline='''\n'''						) as f:
            a						:Union[str, Any]										=	f.readlines()

      a						:Tuple										=	0
      while line_index < len(lowerCAmelCase__						) and not lines[line_index].startswith('''_import_structure = {'''						):
            line_index += 1

      # If this is a traditional init, just return.
      if line_index >= len(lowerCAmelCase__						):
            return None

      # First grab the objects without a specific backend in _import_structure
      a						:Dict										=	[]
      while not lines[line_index].startswith('''if TYPE_CHECKING'''						) and find_backend(lines[line_index]						) is None:
            a						:int										=	lines[line_index]
            # If we have everything on a single line, let's deal with it.
            if _re_one_line_import_struct.search(lowerCAmelCase__						):
                  a						:Optional[int]										=	_re_one_line_import_struct.search(lowerCAmelCase__						).groups()[0]
                  a						:str										=	re.findall('''\[([^\]]+)\]'''			,  lowerCAmelCase__						)
                  for imp in imports:
                        objects.extend([obj[1:-1] for obj in imp.split(''', '''						)]						)
                  line_index += 1
                  continue
            a						:Tuple										=	_re_import_struct_key_value.search(lowerCAmelCase__						)
            if single_line_import_search is not None:
                  a						:Optional[int]										=	[obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', '''						) if len(lowerCAmelCase__						) > 0]
                  objects.extend(lowerCAmelCase__						)
            elif line.startswith(''' ''' * 8 + '''\"'''						):
                  objects.append(line[9:-3]						)
            line_index += 1

      a						:Dict										=	{'''none''': objects}
      # Let's continue with backend-specific objects in _import_structure
      while not lines[line_index].startswith('''if TYPE_CHECKING'''						):
            # If the line is an if not is_backend_available, we grab all objects associated.
            a						:Any										=	find_backend(lines[line_index]						)
            # Check if the backend declaration is inside a try block:
            if _re_try.search(lines[line_index - 1]						) is None:
                  a						:Tuple										=	None

            if backend is not None:
                  line_index += 1

                  # Scroll until we hit the else block of try-except-else
                  while _re_else.search(lines[line_index]						) is None:
                        line_index += 1

                  line_index += 1

                  a						:str										=	[]
                  # Until we unindent, add backend objects to the list
                  while len(lines[line_index]						) <= 1 or lines[line_index].startswith(''' ''' * 4						):
                        a						:Dict										=	lines[line_index]
                        if _re_import_struct_add_one.search(lowerCAmelCase__						) is not None:
                              objects.append(_re_import_struct_add_one.search(lowerCAmelCase__						).groups()[0]						)
                        elif _re_import_struct_add_many.search(lowerCAmelCase__						) is not None:
                              a						:List[str]										=	_re_import_struct_add_many.search(lowerCAmelCase__						).groups()[0].split(''', '''						)
                              a						:Dict										=	[obj[1:-1] for obj in imports if len(lowerCAmelCase__						) > 0]
                              objects.extend(lowerCAmelCase__						)
                        elif _re_between_brackets.search(lowerCAmelCase__						) is not None:
                              a						:str										=	_re_between_brackets.search(lowerCAmelCase__						).groups()[0].split(''', '''						)
                              a						:Any										=	[obj[1:-1] for obj in imports if len(lowerCAmelCase__						) > 0]
                              objects.extend(lowerCAmelCase__						)
                        elif _re_quote_object.search(lowerCAmelCase__						) is not None:
                              objects.append(_re_quote_object.search(lowerCAmelCase__						).groups()[0]						)
                        elif line.startswith(''' ''' * 8 + '''\"'''						):
                              objects.append(line[9:-3]						)
                        elif line.startswith(''' ''' * 12 + '''\"'''						):
                              objects.append(line[13:-3]						)
                        line_index += 1

                  a						:str										=	objects
            else:
                  line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
      a						:Any										=	[]
      while (
          line_index < len(lowerCAmelCase__						)
          and find_backend(lines[line_index]						) is None
          and not lines[line_index].startswith('''else'''						)
      ):
            a						:Optional[Any]										=	lines[line_index]
            a						:Optional[Any]										=	_re_import.search(lowerCAmelCase__						)
            if single_line_import_search is not None:
                  objects.extend(single_line_import_search.groups()[0].split(''', '''						)						)
            elif line.startswith(''' ''' * 8						):
                  objects.append(line[8:-2]						)
            line_index += 1

      a						:List[Any]										=	{'''none''': objects}
      # Let's continue with backend-specific objects
      while line_index < len(lowerCAmelCase__						):
            # If the line is an if is_backend_available, we grab all objects associated.
            a						:List[str]										=	find_backend(lines[line_index]						)
            # Check if the backend declaration is inside a try block:
            if _re_try.search(lines[line_index - 1]						) is None:
                  a						:List[Any]										=	None

            if backend is not None:
                  line_index += 1

                  # Scroll until we hit the else block of try-except-else
                  while _re_else.search(lines[line_index]						) is None:
                        line_index += 1

                  line_index += 1

                  a						:List[str]										=	[]
                  # Until we unindent, add backend objects to the list
                  while len(lines[line_index]						) <= 1 or lines[line_index].startswith(''' ''' * 8						):
                        a						:Any										=	lines[line_index]
                        a						:Optional[Any]										=	_re_import.search(lowerCAmelCase__						)
                        if single_line_import_search is not None:
                              objects.extend(single_line_import_search.groups()[0].split(''', '''						)						)
                        elif line.startswith(''' ''' * 12						):
                              objects.append(line[12:-2]						)
                        line_index += 1

                  a						:Any										=	objects
            else:
                  line_index += 1

      return import_dict_objects, type_hint_objects
def     __lowerCamelCase						(			UpperCAmelCase_						:		str			,  UpperCAmelCase_						:		Dict						):




      """simple docstring"""





      def find_duplicates(UpperCAmelCase_						:		int						):
            return [k for k, v in collections.Counter(lowerCAmelCase__						).items() if v > 1]

      if list(import_dict_objects.keys()						) != list(type_hint_objects.keys()						):
            return ["Both sides of the init do not have the same backends!"]

      a						:int										=	[]
      for key in import_dict_objects.keys():
            a						:Dict										=	find_duplicates(import_dict_objects[key]						)
            if duplicate_imports:
                  errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''						)
            a						:List[Any]										=	find_duplicates(type_hint_objects[key]						)
            if duplicate_type_hints:
                  errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'''						)

            if sorted(set(import_dict_objects[key]						)						) != sorted(set(type_hint_objects[key]						)						):
                  a						:Optional[int]										=	'''base imports''' if key == '''none''' else F'''{key} backend'''
                  errors.append(F'''Differences for {name}:'''						)
                  for a in type_hint_objects[key]:
                        if a not in import_dict_objects[key]:
                              errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.'''						)
                  for a in import_dict_objects[key]:
                        if a not in type_hint_objects[key]:
                              errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.'''						)
      return errors
def     __lowerCamelCase						(			):




      """simple docstring"""





      a						:Optional[Any]										=	[]
      for root, _, files in os.walk(lowerCAmelCase__						):
            if "__init__.py" in files:
                  a						:int										=	os.path.join(lowerCAmelCase__			,  '''__init__.py'''						)
                  a						:Tuple										=	parse_init(lowerCAmelCase__						)
                  if objects is not None:
                        a						:List[str]										=	analyze_results(*lowerCAmelCase__						)
                        if len(lowerCAmelCase__						) > 0:
                              a						:int										=	F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
                              failures.append('''\n'''.join(lowerCAmelCase__						)						)
      if len(lowerCAmelCase__						) > 0:
            raise ValueError('''\n\n'''.join(lowerCAmelCase__						)						)
def     __lowerCamelCase						(			):




      """simple docstring"""





      a						:str										=	[]
      for path, directories, files in os.walk(lowerCAmelCase__						):
            for folder in directories:
                  # Ignore private modules
                  if folder.startswith('''_'''						):
                        directories.remove(lowerCAmelCase__						)
                        continue
                  # Ignore leftovers from branches (empty folders apart from pycache)
                  if len(list((Path(lowerCAmelCase__						) / folder).glob('''*.py'''						)						)						) == 0:
                        continue
                  a						:Tuple										=	str((Path(lowerCAmelCase__						) / folder).relative_to(lowerCAmelCase__						)						)
                  a						:int										=	short_path.replace(os.path.sep			,  '''.'''						)
                  submodules.append(lowerCAmelCase__						)
            for fname in files:
                  if fname == "__init__.py":
                        continue
                  a						:List[str]										=	str((Path(lowerCAmelCase__						) / fname).relative_to(lowerCAmelCase__						)						)
                  a						:List[Any]										=	short_path.replace('''.py'''			,  ''''''						).replace(os.path.sep			,  '''.'''						)
                  if len(submodule.split('''.'''						)						) == 1:
                        submodules.append(lowerCAmelCase__						)
      return submodules


snake_case    :   str	    =					[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
]
def     __lowerCamelCase						(			):




      """simple docstring"""





      a						:Union[str, Any]										=	importlib.util.spec_from_file_location(
          '''transformers'''			,  os.path.join(lowerCAmelCase__			,  '''__init__.py'''						)			,  submodule_search_locations=[PATH_TO_TRANSFORMERS]			,  )
      a						:Optional[int]										=	spec.loader.load_module()

      a						:Any										=	[
          module
          for module in get_transformers_submodules()
          if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
      ]
      if len(lowerCAmelCase__						) > 0:
            a						:Any										=	'''\n'''.join(F'''- {module}''' for module in module_not_registered						)
            raise ValueError(
                '''The following submodules are not properly registered in the main init of Transformers:\n'''
                F'''{list_of_modules}\n'''
                '''Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'''						)


if __name__ == "__main__":
     check_all_inits()
     check_submodules()









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  :




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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Dict										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )
       a						:Optional[Any]										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )

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

       a						: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 	SCREAMING_SNAKE_CASE__    (		self   ):
       random.seed(self.seed   )
       tf.random.set_seed(self.seed   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:int										=	TFTransfoXLModel(_lowerCamelCase   )

       a							,    a						:List[Any]										=	model(_lowerCamelCase   ).to_tuple()

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

       a							,    a						:Optional[int]										=	model(_lowerCamelCase   ).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 ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:str										=	TFTransfoXLLMHeadModel(_lowerCamelCase   )

       a							,    a						:Tuple										=	model(_lowerCamelCase   ).to_tuple()

       a						:Any										=	{'''input_ids''': input_ids_a, '''labels''': lm_labels}
       a							,    a						:Dict										=	model(_lowerCamelCase   ).to_tuple()

       a							,    a						:Dict										=	model([input_ids_a, mems_a]   ).to_tuple()

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

       a							,    a						:Any										=	model(_lowerCamelCase   ).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 ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:Optional[Any]										=	TFTransfoXLForSequenceClassification(_lowerCamelCase   )
       a						:Any										=	model(_lowerCamelCase   )
       self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.prepare_config_and_inputs()
       ((a)							,    (a)							,    (a)							,    (a))						:Optional[int]										=	config_and_inputs
       a						:Union[str, Any]										=	{'''input_ids''': input_ids_a}
       return config, inputs_dict







@require_tf
class 		_snake_case  (				_snake_case						,   _snake_case						,   unittest.TestCase							):
 SCREAMING_SNAKE_CASE__				=	(
     (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
 )
 SCREAMING_SNAKE_CASE__				=	() if is_tf_available() else ()
 SCREAMING_SNAKE_CASE__				=	(
     {
         '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
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       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   ):
       a						:str										=	TFTransfoXLModelTester(self   )
       a						:str										=	ConfigTester(self ,  config_class=_lowerCamelCase ,  d_embed=37   )




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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:str										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:Dict										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a							,    a						:Any										=	self.model_tester.prepare_config_and_inputs_for_common()
       a						:int										=	[TFTransfoXLForSequenceClassification]

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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       # TODO JP: Make TransfoXL XLA compliant
       pass




 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a						:List[Any]										=	TFTransfoXLModel.from_pretrained(_lowerCamelCase   )
             self.assertIsNotNone(_lowerCamelCase   )




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







@require_tf
class 		_snake_case  (				unittest.TestCase							):




 @unittest.skip('''Skip test until #12651 is resolved.'''   )
 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Any										=	TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''   )
       # fmt: off
       a						:Union[str, Any]										=	tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,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
       a						:List[Any]										=	[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,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>

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





