
import unittest

import numpy as np

from transformers import (
    GPTSanJapaneseConfig,
    GPTSanJapaneseForConditionalGeneration,
    GPTSanJapaneseModel,
    GPTSanJapaneseTokenizer,
    is_torch_available,
)
from transformers.generation import GenerationConfig
from transformers.testing_utils import require_torch, slow, tooslow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin





class   __UpperCamelCase				:






     """simple docstring"""







     def __init__(							self    :    str      ,		_A    :    List[str]      ,		_A    :    Union[str, Any]=3_6000      ,		_A    :    int=13      ,		_A    :    Optional[Any]=7      ,		_A    :    str=True      ,		_A    :    Optional[int]=32      ,		_A    :    Optional[int]=42      ,		_A    :    Dict=5      ,		_A    :    List[Any]=2      ,		_A    :    List[str]=4      ,		_A    :    List[str]=2      ,		_A    :    Dict=32      ,		_A    :    List[str]=80      ,		_A    :    int=33      ,		_A    :    Optional[Any]=0.0      ,		_A    :    Union[str, Any]=1e-6      ,		_A    :    Union[str, Any]=100      ,		_A    :    int=0.0      ,		):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					str			=						vocab_size
       __SCREAMING_SNAKE_CASE     :					Tuple			=						parent
       __SCREAMING_SNAKE_CASE     :					List[str]			=						batch_size
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						num_contexts
       # For common tests
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						self.num_contexts
       __SCREAMING_SNAKE_CASE     :					Tuple			=						is_training
       __SCREAMING_SNAKE_CASE     :					int			=						hidden_size
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						num_ext_layers
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						ext_size
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						num_hidden_layers
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						num_attention_heads
       __SCREAMING_SNAKE_CASE     :					str			=						num_experts
       __SCREAMING_SNAKE_CASE     :					Any			=						d_ff
       __SCREAMING_SNAKE_CASE     :					Dict			=						d_ext
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						d_spout
       __SCREAMING_SNAKE_CASE     :					Tuple			=						dropout_rate
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						layer_norm_epsilon
       __SCREAMING_SNAKE_CASE     :					Dict			=						expert_capacity
       __SCREAMING_SNAKE_CASE     :					Tuple			=						router_jitter_noise



     def 				UpperCAmelCase__    (							self    :    List[str]				):







       """simple docstring"""




       return GPTSanJapaneseConfig.from_pretrained('''Tanrei/GPTSAN-japanese'''				)



     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[Any]			=						ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size				)

       __SCREAMING_SNAKE_CASE     :					Tuple			=						self.get_config()

       return (config, input_ids)



     def 				UpperCAmelCase__    (							self    :    List[Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					str			=						ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size				)

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						self.get_config()

       return (config, {"input_ids": input_ids})



     def 				UpperCAmelCase__    (							self    :    Optional[Any]				):







       """simple docstring"""




       return GPTSanJapaneseConfig(
           vocab_size=self.vocab_size      ,		num_contexts=self.seq_length      ,		d_model=self.hidden_size      ,		d_ff=self.d_ff      ,		d_ext=self.d_ext      ,		d_spout=self.d_spout      ,		num_switch_layers=self.num_hidden_layers - self.num_ext_layers      ,		num_ext_layers=self.num_ext_layers      ,		num_heads=self.num_attention_heads      ,		num_experts=self.num_experts      ,		expert_capacity=self.expert_capacity      ,		dropout_rate=self.dropout_rate      ,		layer_norm_epsilon=self.layer_norm_epsilon      ,		router_jitter_noise=self.router_jitter_noise      ,		)




     def 				UpperCAmelCase__    (							self    :    Tuple      ,		_A    :    int      ,		_A    :    List[Any]      ,		):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Any			=						GPTSanJapaneseForConditionalGeneration(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Dict			=						model(
           input_ids=_A      ,		)
       self.parent.assertIsNotNone(_A				)






@require_torch
class   __UpperCamelCase				(    lowerCAmelCase__				,		lowerCAmelCase__				,		unittest.TestCase   ):






     """simple docstring"""







     lowerCAmelCase_     =	(GPTSanJapaneseModel,) if is_torch_available() else ()
     lowerCAmelCase_     =	(
         {
             '''conversational''': GPTSanJapaneseForConditionalGeneration,
             '''feature-extraction''': GPTSanJapaneseForConditionalGeneration,
             '''summarization''': GPTSanJapaneseForConditionalGeneration,
             '''text2text-generation''': GPTSanJapaneseForConditionalGeneration,
             '''translation''': GPTSanJapaneseForConditionalGeneration,
         }
         if is_torch_available()
         else {}
     )
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
     lowerCAmelCase_     =	[0.8, 0.9]



     def 				UpperCAmelCase__    (							self    :    Optional[Any]      ,		_A    :    List[str]      ,		_A    :    Optional[int]      ,		_A    :    Optional[Any]      ,		_A    :    List[str]      ,		_A    :    List[Any]				):







       """simple docstring"""




       if pipeline_test_casse_name == "SummarizationPipelineTests":
         # TODO: fix `_reorder_cache` is not implemented for this model
         return True
       elif pipeline_test_casse_name == "Text2TextGenerationPipelineTests":
         # TODO: check this.
         return True

       return False



     def 				UpperCAmelCase__    (							self    :    List[str]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					int			=						GPTSanJapaneseTester(self				)
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						ConfigTester(self      ,		config_class=_A      ,		d_model=37				)



     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       GPTSanJapaneseConfig()



     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A				)



     @unittest.skip(
         reason='''skip for now as the computed `max_memory` by `model_split_percents` in the test method will be changed inside `from_pretrained`'''				)
     def 				UpperCAmelCase__    (							self    :    int				):







       """simple docstring"""




       super().test_model_parallelism()




     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''				)
     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       pass






@require_torch
class   __UpperCamelCase				(    lowerCAmelCase__				,		lowerCAmelCase__				,		unittest.TestCase   ):






     """simple docstring"""







     lowerCAmelCase_     =	(GPTSanJapaneseForConditionalGeneration,) if is_torch_available() else ()
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     lowerCAmelCase_     =	False
     # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
     lowerCAmelCase_     =	[0.8, 0.9]



     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Tuple			=						GPTSanJapaneseTester(self				)
       __SCREAMING_SNAKE_CASE     :					List[str]			=						ConfigTester(self      ,		config_class=_A      ,		d_model=37				)



     def 				UpperCAmelCase__    (							self    :    List[str]				):







       """simple docstring"""




       GPTSanJapaneseConfig()



     def 				UpperCAmelCase__    (							self    :    Dict				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A				)



     @unittest.skip(
         reason='''skip for now as the computed `max_memory` by `model_split_percents` in the test method will be changed inside `from_pretrained`'''				)
     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       super().test_model_parallelism()



     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''				)
     def 				UpperCAmelCase__    (							self    :    Dict				):







       """simple docstring"""




       pass



     @slow
     def 				UpperCAmelCase__    (							self    :    Optional[Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						GPTSanJapaneseForConditionalGeneration.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						GPTSanJapaneseTokenizer.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						tokenizer.encode('''武田信玄は'''      ,		return_tensors='''pt'''				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						model(_A				)
       __SCREAMING_SNAKE_CASE     :					List[str]			=						outputs.logits.detach().cpu().numpy()
       # Output of original model created with mesh-tensoflow
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						[
           # fmt: off
           [-12.0_37_83_98_89_52_63_67, -12.4_33_06_15_99_73_14_45, -14.3_33_84_03_70_17_82_23, -12.4_50_34_59_93_04_19_92, -11.1_66_13_76_95_31_25,
           -11.9_30_13_76_34_27_73_44, -10.6_59_74_04_47_99_80_47, -12.9_09_57_45_08_66_69_92, -13.2_41_04_30_90_82_03_12, -13.3_98_57_95_97_47_31_45,
           -11.1_07_52_48_71_82_61_72, -12.3_68_59_41_69_61_67, -22.97_94_31_15_23_43_75, -10.4_81_06_76_57_47_07_03, -12.4_84_03_07_23_57_17_77,
           -12.8_07_36_06_49_10_88_87, -14.7_69_70_00_50_35_40_04, -12.2_33_57_96_35_62_01_17, -13.4_28_14_54_08_63_03_71, -22.6_24_17_79_32_73_92_58],
           [-7.5_11_14_98_83_27_02_64, -8.2_81_85_17_68_49_36_52, -7.9_43_12_71_55_30_39_55, -7.55_02_13_33_69_44_58, -6.49_86_99_66_50_69_58,
           -7.5_86_79_62_83_72_19_24, -6.9_78_08_59_94_72_04_59, -7.8_39_14_51_83_56_32_32, -8.21_96_41_68_54_85_84, -8.6_95_09_12_47_55_85_94,
           -6.7_06_91_06_10_19_89_75, -6.65_85_79_82_63_54_98_05, -19.5_65_69_86_23_65_72_27, -5.3_53_84_27_35_29_05_27, -8.3_50_68_60_73_30_32_23,
           -8.0_39_38_86_56_61_62_11, -10.8_56_56_92_90_16_11_33, -7.75_15_44_47_55_55_42, -8.8_19_02_21_78_64_99_02, -19.51_53_27_45_36_13_28],
           [-9.73_06_62_34_58_86_23, -10.2_23_92_27_29_49_21_88, -9.9_32_98_14_91_08_88_67, -11.8_57_83_67_23_32_76_37, -7.6_62_62_62_66_47_94_92,
           -11.13_52_91_09_95_48_34, -7.7_65_09_76_18_10_30_27, -11.4_72_92_32_78_80_85_94, -9.5_43_14_99_48_12_01_17, -11.9_05_63_39_26_39_16_02,
           -9.3_66_16_42_07_45_84_96, -11.5_73_42_81_53_99_17, -23.6_99_00_32_19_60_44_92, -9.4_29_59_02_25_21_97_27, -10.42_83_92_41_02_78_32,
           -10.5_85_24_03_64_07_47_07, -10.94_77_19_57_39_74_61, -11.0_95_41_60_69_03_07_62, -10.3_90_24_06_69_25_04_88, -23.7_69_37_29_40_06_34_77],
           [-9.7_28_26_57_62_32_91_02, -9.8_59_71_26_00_70_80_08, -10.09_72_92_90_00_85_45, -9.6_78_52_21_09_98_53_52, -6.8_79_51_99_39_42_26_07,
           -9.68_48_75_48_82_81_25, -4.28_03_42_57_88_87_93_95, -10.0_18_91_42_22_71_72_85, -9.3_08_44_59_30_48_09_57, -10.63_39_45_46_50_87_89,
           -8.0_83_64_67_74_29_19_92, -9.06_30_14_98_41_30_86, -21.9_04_26_63_57_42_18_75, -8.90_16_08_46_71_02_05, -8.8_41_87_60_29_96_82_62,
           -11.8_56_71_99_70_70_31_25, -12.0_79_39_81_55_21_24_02, -11.2_33_75_32_04_34_57_03, -10.1_77_33_86_00_15_86_91, -21.87_25_66_22_31_44_53],
           [-9.6_69_76_45_18_73_77_93, -9.6_14_19_86_84_69_23_83, -9.8_14_51_03_45_45_89_84, -9.9_96_50_19_22_60_74_22, -11.3_75_69_04_60_20_50_78,
           -10.1_13_40_52_27_66_11_33, -10.5_46_86_73_70_60_54_69, -10.04_36_90_68_14_57_52, -10.9_07_80_92_57_50_73_24, -10.5_04_21_61_94_15_28_32,
           -11.1_29_19_90_28_01_51_37, -10.1_51_12_40_00_54_93_16, -21.96_58_67_99_62_15_82, -9.0_86_34_94_87_30_46_88, -11.7_30_33_90_50_29_29_69,
           -10.4_60_66_76_10_16_84_57, -10.2_98_04_99_26_75_78_12, -10.7_84_14_82_16_24_75_59, -10.8_40_69_34_73_81_59_18, -22.03_15_28_47_29_00_39],
           # fmt: on
       ]
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						np.array(_A				).flatten()
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						output_logits[0, :, :20].flatten()

       def check(_A    :    List[Any]      ,		_A    :    List[Any]      ,		_A    :    Dict=5e-4				):
         return abs(a - b				) < epsilon * max(abs(_A				)      ,		abs(_A				)				)

       self.assertTrue(np.all([check(target[i]      ,		predict[i]				) for i in range(len(_A				)				)]				)				)



     @slow
     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					int			=						GPTSanJapaneseForConditionalGeneration.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					str			=						GPTSanJapaneseTokenizer.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       model.to(_A				)

       # set deterministically
       __SCREAMING_SNAKE_CASE     :					int			=						GenerationConfig.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						1

       # use different length sentences to test batching
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						[
           '''甲斐なら武田と言うほど''',
           '''織田信長は、''',
       ]

       __SCREAMING_SNAKE_CASE     :					Dict			=						'''left'''
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						tokenizer(_A      ,		return_tensors='''pt'''      ,		padding=_A				)
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						inputs['''input_ids'''].to(_A				)

       self.assertNotEqual(inputs['''attention_mask'''][0].numpy().tolist()      ,		inputs['''attention_mask'''][1].numpy().tolist()				)

       __SCREAMING_SNAKE_CASE     :					str			=						model.generate(
           input_ids=_A      ,		attention_mask=inputs['''attention_mask'''].to(_A				)      ,		max_new_tokens=3      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					Dict			=						tokenizer(sentences[0]      ,		return_tensors='''pt'''				).input_ids.to(_A				)
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model.generate(
           input_ids=_A      ,		max_new_tokens=3      ,		generation_config=_A				)

       __SCREAMING_SNAKE_CASE     :					str			=						tokenizer(sentences[1]      ,		return_tensors='''pt'''				).input_ids.to(_A				)
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						model.generate(input_ids=_A      ,		max_new_tokens=3      ,		generation_config=_A				)

       self.assertNotEqual(inputs_non_padded.shape      ,		inputs_padded.shape				)

       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						tokenizer.batch_decode(_A      ,		skip_special_tokens=_A				)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						tokenizer.decode(output_non_padded[0]      ,		skip_special_tokens=_A				)
       __SCREAMING_SNAKE_CASE     :					Any			=						tokenizer.decode(output_padded[0]      ,		skip_special_tokens=_A				)

       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						[
           '''甲斐なら武田と言うほど甲斐の武田''',
           '''織田信長は、このような''',
       ]
       self.assertListEqual(_A      ,		_A				)
       self.assertListEqual(_A      ,		[non_padded_sentence, padded_sentence]				)



     @tooslow
     def 				UpperCAmelCase__    (							self    :    Union[str, Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Dict			=						GPTSanJapaneseForConditionalGeneration.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						GPTSanJapaneseTokenizer.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       # Output of original model created with mesh-tensoflow
       __SCREAMING_SNAKE_CASE     :					Dict			=						[
           ('''武田信玄は''', 3_5675),
           ('''武田信玄は、''', 45),
           ('''武田信玄は、この''', 29),
           ('''武田信玄は、このよう''', 3_0642),
           ('''武田信玄は、このような''', 3_5680),
           ('''武田信玄は、このような「''', 8640),
           ('''武田信玄は、このような「武田''', 3_1617),
           ('''武田信玄は、このような「武田家''', 3_0646),
           ('''武田信玄は、このような「武田家の''', 3_1617),
           ('''武田信玄は、このような「武田家の家''', 3_1381),
       ]
       for input, output in target:
         __SCREAMING_SNAKE_CASE     :					Tuple			=						tokenizer.encode(_A      ,		return_tensors='''pt'''				)
         __SCREAMING_SNAKE_CASE     :					str			=						model(_A				)
         __SCREAMING_SNAKE_CASE     :					Dict			=						outputs.logits.detach().cpu().numpy()[0]
         __SCREAMING_SNAKE_CASE     :					List[Any]			=						np.argmax(output_logits[-1]				)
         self.assertEqual(_A      ,		_A				)



     @slow
     def 				UpperCAmelCase__    (							self    :    Any				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Dict			=						GPTSanJapaneseForConditionalGeneration.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Any			=						GPTSanJapaneseTokenizer.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       model.to(_A				)

       # set deterministically
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						GenerationConfig.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					List[str]			=						1

       __SCREAMING_SNAKE_CASE     :					Tuple			=						'''武田信玄は、'''
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						tokenizer(_A      ,		return_tensors='''pt'''				).input_ids.to(_A				)
       __SCREAMING_SNAKE_CASE     :					List[str]			=						tokenizer([input_text, input_text]      ,		return_tensors='''pt'''				).input_ids.to(_A				)

       # spout from uniform and one-hot
       __SCREAMING_SNAKE_CASE     :					str			=						[
           # fmt: off
           [0.87_88_22_08, 0.38_42_63_96, 0.33_22_02_48, 0.43_89_04_06, 0.16_56_22_52,
           0.04_80_39_85, 0.21_15_72  , 0.23_18_84_73, 0.37_15_30_68, 0.7_83_63_77 ,
           0.02_16_01_72, 0.38_76_17_19, 0.75_29_07_72, 0.90_19_88_57, 0.34_36_57_77,
           0.64_16_81_69, 0.44_31_84_71, 0.14_57_57_46, 0.92_56_28_81, 0.40_81_21_48,
           0.29_01_91_22, 0.88_86_15_99, 0.65_52_48_46, 0.43_56_34_56, 0.38_17_71_87,
           0.70_83_29_65, 0.81_52_78_92, 0.68_83_28_12, 0.38_83_31_92, 0.4_56_15_22 ,
           0.14_82_88_17, 0.47_24_82_13, 0.54_35_73_35, 0.82_00_95_66, 0.1_33_88_84 ,
           0.02_75_54_17, 0.19_76_46_77, 0.2_42_20_84 , 0.04_75_76_74, 0.65_40_96_06,
           0.0_82_45_89 , 0.03_30_43_83, 0.94_38_76_89, 0.98_76_45_09, 0.82_43_39_01,
           0.27_64_67_41, 0.64_90_74_93, 0.76_00_94_06, 0.30_08_79_15, 0.17_90_46_89,
           0.41_60_17_14, 0.67_04_63_98, 0.10_42_28_22, 0.08_44_73_74, 0.07_35_43_44,
           0.61_42_35_65, 0.70_28_48_66, 0.7_53_23_33 , 0.1_97_20_38 , 0.29_57_56_59,
           0.90_58_38_86, 0.29_26_53_07, 0.50_00_01_75, 0.70_40_76_55, 0.88_93_63  ,
           0.81_90_44_18, 0.66_82_91_28, 0.64_46_88_15, 0.56_56_37_23, 0.85_60_18_75,
           0.94_92_46_72, 0.00_16_67_62, 0.25_22_06_43, 0.74_54_02_19, 0.67_99_32_47,
           0.1_54_96_75 , 0.39_38_53_52, 0.92_15_36_07, 0.63_74_59_31, 0.27_75_90_43,
           0.84_70_22_95, 0.65_90_42_71, 0.58_67_66_14, 0.8_66_69_36 , 0.39_60_74_38,
           0.79_95_49_83, 0.42_22_06_97, 0.39_65_03_81, 0.7_84_98_64 , 0.56_15_02_01,
           0.15_67_89_25, 0.14_74_60_32, 0.34_54_21_14, 0.47_02_67_83, 0.11_95_64_89,
           0.25_42_14_35, 0.33_78_89_01, 0.68_93_48_42, 0.36_42_46_85, 0.71_73_78_98,
           0.38_98_34_49, 0.94_39_37_79, 0.39_57_55_88, 0.36_61_65_53, 0.87_10_46_65,
           0.64_63_02_03, 0.22_51_69_05, 0.88_27_08_04, 0.15_03_13_38, 0.75_14_43_45,
           0.46_45_90_25, 0.85_39_64_54, 0.86_35_56_43, 0.65_13_98_51, 0.70_26_60_61,
           0.30_24_13_89, 0.81_05_64_97, 0.88_86_59_69, 0.38_77_38_07, 0.70_63_58_49,
           0.90_71_84_59, 0.43_24_57_89, 0.28_00_06_54, 0.45_93_55_62, 0.08_77_35_19,
           0.9_55_21_51 , 0.93_90_15_11, 0.22_48_92_88], # uniform
           [1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
            0., 0., 0., 0., 0., 0., 0., 0.],
           # fmt: on
       ]

       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						model.generate(
           input_ids=_A      ,		spout=spouts[0]      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						model.generate(
           input_ids=_A      ,		spout=spouts[1]      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					int			=						model.generate(
           input_ids=_A      ,		spout=_A      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						tokenizer.decode(outputa[0]				)
       __SCREAMING_SNAKE_CASE     :					str			=						tokenizer.decode(outputa[0]				)
       __SCREAMING_SNAKE_CASE     :					str			=						tokenizer.batch_decode(_A				)

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						[
           '''武田信玄は、武田氏の滅亡後、武田氏の居城であった甲斐武田氏の居城である''',
           '''武田信玄は、武田家の滅亡を防ぐため、武田家の家臣である武田信虎を討''',
       ]
       self.assertListEqual(_A      ,		_A				)
       self.assertListEqual(_A      ,		[outa_sentence, outa_sentence]				)




     @slow
     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					str			=						GPTSanJapaneseForConditionalGeneration.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					str			=						GPTSanJapaneseTokenizer.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       model.to(_A				)

       # set deterministically
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						GenerationConfig.from_pretrained('''Tanrei/GPTSAN-japanese'''				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						1

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						'''武田信玄'''
       __SCREAMING_SNAKE_CASE     :					str			=						'''織田信長'''
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						'''は、'''
       __SCREAMING_SNAKE_CASE     :					int			=						'''が、'''
       __SCREAMING_SNAKE_CASE     :					str			=						tokenizer(_A      ,		prefix_text=_A      ,		return_tensors='''pt'''				)
       __SCREAMING_SNAKE_CASE     :					Dict			=						tokenizer(_A      ,		prefix_text=_A      ,		return_tensors='''pt'''				)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						tokenizer([[prefix_text_a, input_text_a], [prefix_text_a, input_text_a]]      ,		return_tensors='''pt'''				)

       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model.generate(
           input_ids=input_tok_a.input_ids.to(_A				)      ,		token_type_ids=input_tok_a.token_type_ids.to(_A				)      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						model.generate(
           input_ids=input_tok_a.input_ids.to(_A				)      ,		token_type_ids=input_tok_a.token_type_ids.to(_A				)      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						model.generate(
           input_ids=input_tok_a.input_ids.to(_A				)      ,		token_type_ids=input_tok_a.token_type_ids.to(_A				)      ,		attention_mask=input_tok_a.attention_mask.to(_A				)      ,		max_new_tokens=20      ,		generation_config=_A      ,		)

       __SCREAMING_SNAKE_CASE     :					Tuple			=						tokenizer.decode(outputa[0]				)
       __SCREAMING_SNAKE_CASE     :					int			=						tokenizer.decode(outputa[0]				)
       __SCREAMING_SNAKE_CASE     :					Any			=						tokenizer.batch_decode(_A				)

       __SCREAMING_SNAKE_CASE     :					List[str]			=						[
           '''武田信玄は、武田氏の祖である武田信虎を、その子・武田信友を擁して''',
           '''織田信長が、織田信長の妻・お市の方を妻として迎えたという逸話が残''',
       ]
       self.assertListEqual(_A      ,		_A				)
       self.assertListEqual(_A      ,		[outa_sentence, outa_sentence]				)


import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
lowercase_											=	"""src/transformers"""

# Matches is_xxx_available()
lowercase_											=	re.compile(R"""is\_([a-z_]*)_available()""")
# Matches from xxx import bla
lowercase_											=	re.compile(R"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")
lowercase_											=	re.compile(R"""^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)""")


lowercase_											=	"""
{0} = None
"""

lowercase_											=	"""
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
"""


lowercase_											=	"""
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""


def     a__			(    snake_case    ):





  """simple docstring"""
  if _re_test_backend.search(snake_case    ) is None:
    return None
  __SCREAMING_SNAKE_CASE     :					Optional[int]			=						[b[0] for b in _re_backend.findall(snake_case    )]
  backends.sort()
  return "_and_".join(snake_case    )


def     a__			(    ):





  """simple docstring"""
  with open(os.path.join(snake_case   ,	'''__init__.py'''    )   ,	'''r'''   ,	encoding='''utf-8'''   ,	newline='''\n'''    ) as f:
    __SCREAMING_SNAKE_CASE     :					Tuple			=						f.readlines()

  # Get to the point we do the actual imports for type checking
  __SCREAMING_SNAKE_CASE     :					Any			=						0
  while not lines[line_index].startswith('''if TYPE_CHECKING'''    ):
    line_index += 1

  __SCREAMING_SNAKE_CASE     :					Tuple			=						{}
  # Go through the end of the file
  while line_index < len(snake_case    ):
    # If the line is an if is_backend_available, we grab all objects associated.
    __SCREAMING_SNAKE_CASE     :					int			=						find_backend(lines[line_index]    )
    if backend is not None:
      while not lines[line_index].startswith('''    else:'''    ):
        line_index += 1
      line_index += 1

      __SCREAMING_SNAKE_CASE     :					Any			=						[]
      # Until we unindent, add backend objects to the list
      while len(lines[line_index]    ) <= 1 or lines[line_index].startswith(''' ''' * 8    ):
        __SCREAMING_SNAKE_CASE     :					Dict			=						lines[line_index]
        __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						_re_single_line_import.search(snake_case    )
        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

      __SCREAMING_SNAKE_CASE     :					List[str]			=						objects
    else:
      line_index += 1

  return backend_specific_objects


def     a__			(    snake_case   ,	snake_case    ):





  """simple docstring"""
  if name.isupper():
    return DUMMY_CONSTANT.format(snake_case    )
  elif name.islower():
    return DUMMY_FUNCTION.format(snake_case   ,	snake_case    )
  else:
    return DUMMY_CLASS.format(snake_case   ,	snake_case    )


def     a__			(    snake_case=None    ):





  """simple docstring"""
  if backend_specific_objects is None:
    __SCREAMING_SNAKE_CASE     :					List[Any]			=						read_init()
  # For special correspondence backend to module name as used in the function requires_modulename
  __SCREAMING_SNAKE_CASE     :					Optional[int]			=						{}

  for backend, objects in backend_specific_objects.items():
    __SCREAMING_SNAKE_CASE     :					Tuple			=						'''[''' + ''', '''.join(F'''"{b}"''' for b in backend.split('''_and_'''    )    ) + ''']'''
    __SCREAMING_SNAKE_CASE     :					Optional[int]			=						'''# This file is autogenerated by the command `make fix-copies`, do not edit.\n'''
    dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
    dummy_file += "\n".join([create_dummy_object(snake_case   ,	snake_case    ) for o in objects]    )
    __SCREAMING_SNAKE_CASE     :					List[Any]			=						dummy_file

  return dummy_files


def     a__			(    snake_case=False    ):





  """simple docstring"""
  __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						create_dummy_files()
  # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
  __SCREAMING_SNAKE_CASE     :					str			=						{'''torch''': '''pt'''}

  # Locate actual dummy modules and read their content.
  __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						os.path.join(snake_case   ,	'''utils'''    )
  __SCREAMING_SNAKE_CASE     :					List[Any]			=						{
      backend: os.path.join(snake_case   ,	F'''dummy_{short_names.get(snake_case   ,	snake_case    )}_objects.py'''    )
      for backend in dummy_files.keys()
  }

  __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						{}
  for backend, file_path in dummy_file_paths.items():
    if os.path.isfile(snake_case    ):
      with open(snake_case   ,	'''r'''   ,	encoding='''utf-8'''   ,	newline='''\n'''    ) as f:
        __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						f.read()
    else:
      __SCREAMING_SNAKE_CASE     :					Any			=						''''''

  for backend in dummy_files.keys():
    if dummy_files[backend] != actual_dummies[backend]:
      if overwrite:
        print(
            F'''Updating transformers.utils.dummy_{short_names.get(snake_case   ,	snake_case    )}_objects.py as the main '''
            '''__init__ has new objects.'''    )
        with open(dummy_file_paths[backend]   ,	'''w'''   ,	encoding='''utf-8'''   ,	newline='''\n'''    ) as f:
          f.write(dummy_files[backend]    )
      else:
        raise ValueError(
            '''The main __init__ has objects that are not present in '''
            F'''transformers.utils.dummy_{short_names.get(snake_case   ,	snake_case    )}_objects.py. Run `make fix-copies` '''
            '''to fix this.'''    )


if __name__ == "__main__":
   lowercase_											=	argparse.ArgumentParser()
   parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""")
   lowercase_											=	parser.parse_args()

   check_dummies(args.fix_and_overwrite)
