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

 def __init__(      self     ,	__UpperCamelCase     ,	__UpperCamelCase=3_6_0_0_0     ,	__UpperCamelCase=1_3     ,	__UpperCamelCase=7     ,	__UpperCamelCase=True     ,	__UpperCamelCase=3_2     ,	__UpperCamelCase=4_2     ,	__UpperCamelCase=5     ,	__UpperCamelCase=2     ,	__UpperCamelCase=4     ,	__UpperCamelCase=2     ,	__UpperCamelCase=3_2     ,	__UpperCamelCase=8_0     ,	__UpperCamelCase=3_3     ,	__UpperCamelCase=0.0     ,	__UpperCamelCase=1e-6     ,	__UpperCamelCase=1_0_0     ,	__UpperCamelCase=0.0     ,	):




        """simple docstring"""


        UpperCamelCase_							       =       vocab_size
        UpperCamelCase_							       =       parent
        UpperCamelCase_							       =       batch_size
        UpperCamelCase_							       =       num_contexts
        # For common tests
        UpperCamelCase_							       =       self.num_contexts
        UpperCamelCase_							       =       is_training
        UpperCamelCase_							       =       hidden_size
        UpperCamelCase_							       =       num_ext_layers
        UpperCamelCase_							       =       ext_size
        UpperCamelCase_							       =       num_hidden_layers
        UpperCamelCase_							       =       num_attention_heads
        UpperCamelCase_							       =       num_experts
        UpperCamelCase_							       =       d_ff
        UpperCamelCase_							       =       d_ext
        UpperCamelCase_							       =       d_spout
        UpperCamelCase_							       =       dropout_rate
        UpperCamelCase_							       =       layer_norm_epsilon
        UpperCamelCase_							       =       expert_capacity
        UpperCamelCase_							       =       router_jitter_noise

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


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

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


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

        UpperCamelCase_							       =       self.get_config()

        return (config, input_ids)

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


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

        UpperCamelCase_							       =       self.get_config()

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

 def lowerCamelCase_				(      self     ):




        """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 lowerCamelCase_				(      self     ,	__UpperCamelCase     ,	__UpperCamelCase     ,	):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration(config=a_     )
        model.to(a_     )
        model.eval()
        UpperCamelCase_							       =       model(
            input_ids=a_     ,	)
        self.parent.assertIsNotNone(a_     )



@require_torch
class 		lowercase_       (       __SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	unittest.TestCase				):
 A__						:				Any         =    (GPTSanJapaneseModel,) if is_torch_available() else ()
 A__						:				Union[str, Any]         =    (
     {
         '''conversational''': GPTSanJapaneseForConditionalGeneration,
         '''feature-extraction''': GPTSanJapaneseForConditionalGeneration,
         '''summarization''': GPTSanJapaneseForConditionalGeneration,
         '''text2text-generation''': GPTSanJapaneseForConditionalGeneration,
         '''translation''': GPTSanJapaneseForConditionalGeneration,
     }
     if is_torch_available()
     else {}
 )
 A__						:				Optional[int]         =    False
 A__						:				str         =    False
 A__						:				Dict         =    False
 A__						:				Optional[Any]         =    False
 A__						:				Dict         =    False
 A__						:				Union[str, Any]         =    False
 A__						:				int         =    False
 A__						:				int         =    False
 # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
 A__						:				Any         =    [0.8, 0.9]

 def lowerCamelCase_				(      self     ,	__UpperCamelCase     ,	__UpperCamelCase     ,	__UpperCamelCase     ,	__UpperCamelCase     ,	__UpperCamelCase     ):




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




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseTester(self     )
        UpperCamelCase_							       =       ConfigTester(self     ,	config_class=a_     ,	d_model=3_7     )

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        GPTSanJapaneseConfig()

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       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 lowerCamelCase_				(      self     ):




        """simple docstring"""


        super().test_model_parallelism()

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




        """simple docstring"""


        pass



@require_torch
class 		lowercase_       (       __SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	unittest.TestCase				):
 A__						:				Optional[int]         =    (GPTSanJapaneseForConditionalGeneration,) if is_torch_available() else ()
 A__						:				Optional[int]         =    False
 A__						:				Union[str, Any]         =    False
 A__						:				Optional[int]         =    False
 A__						:				Any         =    False
 A__						:				Tuple         =    False
 A__						:				Union[str, Any]         =    False
 # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
 A__						:				List[Any]         =    [0.8, 0.9]

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseTester(self     )
        UpperCamelCase_							       =       ConfigTester(self     ,	config_class=a_     ,	d_model=3_7     )

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        GPTSanJapaneseConfig()

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       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 lowerCamelCase_				(      self     ):




        """simple docstring"""


        super().test_model_parallelism()

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




        """simple docstring"""


        pass

 @slow
 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       GPTSanJapaneseTokenizer.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       tokenizer.encode("""武田信玄は"""     ,	return_tensors="""pt"""     )
        UpperCamelCase_							       =       model(a_     )
        UpperCamelCase_							       =       outputs.logits.detach().cpu().numpy()
        # Output of original model created with mesh-tensoflow
        UpperCamelCase_							       =       [
            # fmt: off
            [-12.037_839_889_526_367, -12.433_061_599_731_445, -14.333_840_370_178_223, -12.450_345_993_041_992, -11.1_661_376_953_125,
            -11.930_137_634_277_344, -10.659_740_447_998_047, -12.909_574_508_666_992, -13.241_043_090_820_312, -13.398_579_597_473_145,
            -11.107_524_871_826_172, -12.3_685_941_696_167, -22.97_943_115_234_375, -10.481_067_657_470_703, -12.484_030_723_571_777,
            -12.807_360_649_108_887, -14.769_700_050_354_004, -12.233_579_635_620_117, -13.428_145_408_630_371, -22.624_177_932_739_258],
            [-7.511_149_883_270_264, -8.281_851_768_493_652, -7.943_127_155_303_955, -7.55_021_333_694_458, -6.49_869_966_506_958,
            -7.586_796_283_721_924, -6.978_085_994_720_459, -7.839_145_183_563_232, -8.21_964_168_548_584, -8.695_091_247_558_594,
            -6.706_910_610_198_975, -6.6_585_798_263_549_805, -19.565_698_623_657_227, -5.353_842_735_290_527, -8.350_686_073_303_223,
            -8.039_388_656_616_211, -10.856_569_290_161_133, -7.75_154_447_555_542, -8.819_022_178_649_902, -19.51_532_745_361_328],
            [-9.73_066_234_588_623, -10.223_922_729_492_188, -9.932_981_491_088_867, -11.857_836_723_327_637, -7.662_626_266_479_492,
            -11.13_529_109_954_834, -7.765_097_618_103_027, -11.472_923_278_808_594, -9.543_149_948_120_117, -11.905_633_926_391_602,
            -9.366_164_207_458_496, -11.5_734_281_539_917, -23.699_003_219_604_492, -9.429_590_225_219_727, -10.42_839_241_027_832,
            -10.585_240_364_074_707, -10.94_771_957_397_461, -11.095_416_069_030_762, -10.390_240_669_250_488, -23.769_372_940_063_477],
            [-9.728_265_762_329_102, -9.859_712_600_708_008, -10.09_729_290_008_545, -9.678_522_109_985_352, -6.879_519_939_422_607,
            -9.68_487_548_828_125, -4.2_803_425_788_879_395, -10.018_914_222_717_285, -9.308_445_930_480_957, -10.63_394_546_508_789,
            -8.083_646_774_291_992, -9.06_301_498_413_086, -21.904_266_357_421_875, -8.90_160_846_710_205, -8.841_876_029_968_262,
            -11.856_719_970_703_125, -12.079_398_155_212_402, -11.233_753_204_345_703, -10.177_338_600_158_691, -21.87_256_622_314_453],
            [-9.669_764_518_737_793, -9.614_198_684_692_383, -9.814_510_345_458_984, -9.996_501_922_607_422, -11.375_690_460_205_078,
            -10.113_405_227_661_133, -10.546_867_370_605_469, -10.04_369_068_145_752, -10.907_809_257_507_324, -10.504_216_194_152_832,
            -11.129_199_028_015_137, -10.151_124_000_549_316, -21.96_586_799_621_582, -9.086_349_487_304_688, -11.730_339_050_292_969,
            -10.460_667_610_168_457, -10.298_049_926_757_812, -10.784_148_216_247_559, -10.840_693_473_815_918, -22.03_152_847_290_039],
            # fmt: on
        ]
        UpperCamelCase_							       =       np.array(a_     ).flatten()
        UpperCamelCase_							       =       output_logits[0, :, :2_0].flatten()

        def check(__UpperCamelCase     ,	__UpperCamelCase     ,	__UpperCamelCase=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 lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       GPTSanJapaneseTokenizer.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        model.to(a_     )

        # set deterministically
        UpperCamelCase_							       =       GenerationConfig.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       1

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

        UpperCamelCase_							       =       """left"""
        UpperCamelCase_							       =       tokenizer(a_     ,	return_tensors="""pt"""     ,	padding=a_     )
        UpperCamelCase_							       =       inputs["""input_ids"""].to(a_     )

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

        UpperCamelCase_							       =       model.generate(
            input_ids=a_     ,	attention_mask=inputs["""attention_mask"""].to(a_     )     ,	max_new_tokens=3     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       tokenizer(sentences[0]     ,	return_tensors="""pt"""     ).input_ids.to(a_     )
        UpperCamelCase_							       =       model.generate(
            input_ids=a_     ,	max_new_tokens=3     ,	generation_config=a_     )

        UpperCamelCase_							       =       tokenizer(sentences[1]     ,	return_tensors="""pt"""     ).input_ids.to(a_     )
        UpperCamelCase_							       =       model.generate(input_ids=a_     ,	max_new_tokens=3     ,	generation_config=a_     )

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

        UpperCamelCase_							       =       tokenizer.batch_decode(a_     ,	skip_special_tokens=a_     )
        UpperCamelCase_							       =       tokenizer.decode(output_non_padded[0]     ,	skip_special_tokens=a_     )
        UpperCamelCase_							       =       tokenizer.decode(output_padded[0]     ,	skip_special_tokens=a_     )

        UpperCamelCase_							       =       [
            """甲斐なら武田と言うほど甲斐の武田""",
            """織田信長は、このような""",
        ]
        self.assertListEqual(a_     ,	a_     )
        self.assertListEqual(a_     ,	[non_padded_sentence, padded_sentence]     )

 @tooslow
 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       GPTSanJapaneseTokenizer.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        # Output of original model created with mesh-tensoflow
        UpperCamelCase_							       =       [
            ("""武田信玄は""", 3_5_6_7_5),
            ("""武田信玄は、""", 4_5),
            ("""武田信玄は、この""", 2_9),
            ("""武田信玄は、このよう""", 3_0_6_4_2),
            ("""武田信玄は、このような""", 3_5_6_8_0),
            ("""武田信玄は、このような「""", 8_6_4_0),
            ("""武田信玄は、このような「武田""", 3_1_6_1_7),
            ("""武田信玄は、このような「武田家""", 3_0_6_4_6),
            ("""武田信玄は、このような「武田家の""", 3_1_6_1_7),
            ("""武田信玄は、このような「武田家の家""", 3_1_3_8_1),
        ]
        for input, output in target:
               UpperCamelCase_							       =       tokenizer.encode(a_     ,	return_tensors="""pt"""     )
               UpperCamelCase_							       =       model(a_     )
               UpperCamelCase_							       =       outputs.logits.detach().cpu().numpy()[0]
               UpperCamelCase_							       =       np.argmax(output_logits[-1]     )
               self.assertEqual(a_     ,	a_     )

 @slow
 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       GPTSanJapaneseTokenizer.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        model.to(a_     )

        # set deterministically
        UpperCamelCase_							       =       GenerationConfig.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       1

        UpperCamelCase_							       =       """武田信玄は、"""
        UpperCamelCase_							       =       tokenizer(a_     ,	return_tensors="""pt"""     ).input_ids.to(a_     )
        UpperCamelCase_							       =       tokenizer([input_text, input_text]     ,	return_tensors="""pt"""     ).input_ids.to(a_     )

        # spout from uniform and one-hot
        UpperCamelCase_							       =       [
            # fmt: off
            [0.87_882_208, 0.38_426_396, 0.33_220_248, 0.43_890_406, 0.16_562_252,
            0.04_803_985, 0.211_572  , 0.23_188_473, 0.37_153_068, 0.7_836_377 ,
            0.02_160_172, 0.38_761_719, 0.75_290_772, 0.90_198_857, 0.34_365_777,
            0.64_168_169, 0.44_318_471, 0.14_575_746, 0.92_562_881, 0.40_812_148,
            0.29_019_122, 0.88_861_599, 0.65_524_846, 0.43_563_456, 0.38_177_187,
            0.70_832_965, 0.81_527_892, 0.68_832_812, 0.38_833_192, 0.4_561_522 ,
            0.14_828_817, 0.47_248_213, 0.54_357_335, 0.82_009_566, 0.1_338_884 ,
            0.02_755_417, 0.19_764_677, 0.2_422_084 , 0.04_757_674, 0.65_409_606,
            0.0_824_589 , 0.03_304_383, 0.94_387_689, 0.98_764_509, 0.82_433_901,
            0.27_646_741, 0.64_907_493, 0.76_009_406, 0.30_087_915, 0.17_904_689,
            0.41_601_714, 0.67_046_398, 0.10_422_822, 0.08_447_374, 0.07_354_344,
            0.61_423_565, 0.70_284_866, 0.7_532_333 , 0.1_972_038 , 0.29_575_659,
            0.90_583_886, 0.29_265_307, 0.50_000_175, 0.70_407_655, 0.889_363  ,
            0.81_904_418, 0.66_829_128, 0.64_468_815, 0.56_563_723, 0.85_601_875,
            0.94_924_672, 0.00_166_762, 0.25_220_643, 0.74_540_219, 0.67_993_247,
            0.1_549_675 , 0.39_385_352, 0.92_153_607, 0.63_745_931, 0.27_759_043,
            0.84_702_295, 0.65_904_271, 0.58_676_614, 0.8_666_936 , 0.39_607_438,
            0.79_954_983, 0.42_220_697, 0.39_650_381, 0.7_849_864 , 0.56_150_201,
            0.15_678_925, 0.14_746_032, 0.34_542_114, 0.47_026_783, 0.11_956_489,
            0.25_421_435, 0.33_788_901, 0.68_934_842, 0.36_424_685, 0.71_737_898,
            0.38_983_449, 0.94_393_779, 0.39_575_588, 0.36_616_553, 0.87_104_665,
            0.64_630_203, 0.22_516_905, 0.88_270_804, 0.15_031_338, 0.75_144_345,
            0.46_459_025, 0.85_396_454, 0.86_355_643, 0.65_139_851, 0.70_266_061,
            0.30_241_389, 0.81_056_497, 0.88_865_969, 0.38_773_807, 0.70_635_849,
            0.90_718_459, 0.43_245_789, 0.28_000_654, 0.45_935_562, 0.08_773_519,
            0.9_552_151 , 0.93_901_511, 0.22_489_288], # 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
        ]

        UpperCamelCase_							       =       model.generate(
            input_ids=a_     ,	spout=spouts[0]     ,	max_new_tokens=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       model.generate(
            input_ids=a_     ,	spout=spouts[1]     ,	max_new_tokens=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       model.generate(
            input_ids=a_     ,	spout=a_     ,	max_new_tokens=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       tokenizer.decode(outputa[0]     )
        UpperCamelCase_							       =       tokenizer.decode(outputa[0]     )
        UpperCamelCase_							       =       tokenizer.batch_decode(a_     )

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

 @slow
 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        UpperCamelCase_							       =       GPTSanJapaneseForConditionalGeneration.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       GPTSanJapaneseTokenizer.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        model.to(a_     )

        # set deterministically
        UpperCamelCase_							       =       GenerationConfig.from_pretrained("""Tanrei/GPTSAN-japanese"""     )
        UpperCamelCase_							       =       1

        UpperCamelCase_							       =       """武田信玄"""
        UpperCamelCase_							       =       """織田信長"""
        UpperCamelCase_							       =       """は、"""
        UpperCamelCase_							       =       """が、"""
        UpperCamelCase_							       =       tokenizer(a_     ,	prefix_text=a_     ,	return_tensors="""pt"""     )
        UpperCamelCase_							       =       tokenizer(a_     ,	prefix_text=a_     ,	return_tensors="""pt"""     )
        UpperCamelCase_							       =       tokenizer([[prefix_text_a, input_text_a], [prefix_text_a, input_text_a]]     ,	return_tensors="""pt"""     )

        UpperCamelCase_							       =       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=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       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=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       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=2_0     ,	generation_config=a_     ,	)

        UpperCamelCase_							       =       tokenizer.decode(outputa[0]     )
        UpperCamelCase_							       =       tokenizer.decode(outputa[0]     )
        UpperCamelCase_							       =       tokenizer.batch_decode(a_     )

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





import hashlib
import importlib.util
import json
import os
import pathlib
from types import ModuleType

import pytest
import requests

_A	  =					pathlib.Path.cwd().joinpath('''project_euler''')
_A	  =					pathlib.Path.cwd().joinpath(
    '''scripts''', '''project_euler_answers.json'''
)

with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
      _A	  =					json.load(file_handle)




def 				lowerCamelCase__				(						a__  :  pathlib.Path     )		->	ModuleType:
       UpperCamelCase_							       =       importlib.util.spec_from_file_location(file_path.name	,      str(a__     )     )
       UpperCamelCase_							       =       importlib.util.module_from_spec(a__     )  # type: ignore
       spec.loader.exec_module(a__     )  # type: ignore
       return module




def 				lowerCamelCase__				(						)		->	list[pathlib.Path]:
       UpperCamelCase_							       =       []
       for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
              if problem_dir_path.is_file() or problem_dir_path.name.startswith("""_"""     ):
                     continue
              for file_path in problem_dir_path.iterdir():
                     if file_path.suffix != ".py" or file_path.name.startswith(("""_""", """test""")     ):
                            continue
                     solution_file_paths.append(a__     )
       return solution_file_paths




def 				lowerCamelCase__				(						)		->	str:
       with open(os.environ["""GITHUB_EVENT_PATH"""]     ) as file:
              UpperCamelCase_							       =       json.load(a__     )
       return event["pull_request"]["url"] + "/files"




def 				lowerCamelCase__				(						)		->	list[pathlib.Path]:
       UpperCamelCase_							       =       []
       UpperCamelCase_							       =       {
           """Accept""": """application/vnd.github.v3+json""",
           """Authorization""": """token """ + os.environ["""GITHUB_TOKEN"""],
       }
       UpperCamelCase_							       =       requests.get(get_files_url()	,      headers=a__     ).json()
       for file in files:
              UpperCamelCase_							       =       pathlib.Path.cwd().joinpath(file["""filename"""]     )
              if (
                  filepath.suffix != ".py"
                  or filepath.name.startswith(("""_""", """test""")     )
                  or not filepath.name.startswith("""sol"""     )
              ):
                     continue
              solution_file_paths.append(a__     )
       return solution_file_paths




def 				lowerCamelCase__				(						)		->	list[pathlib.Path]:
       if os.environ.get("""CI"""     ) and os.environ.get("""GITHUB_EVENT_NAME"""     ) == "pull_request":
              # Return only if there are any, otherwise default to all solutions
              if filepaths := added_solution_file_path():
                     return filepaths
       return all_solution_file_paths()







@pytest.mark.parametrize(
    """solution_path"""	,      collect_solution_file_paths()	,      ids=lambda a__     : f'''{path.parent.name}/{path.name}'''	,      )
def 				lowerCamelCase__				(						a__  :  pathlib.Path     )		->	None:
       UpperCamelCase_							       =       solution_path.parent.name[8:].zfill(3     )
       UpperCamelCase_							       =       PROBLEM_ANSWERS[problem_number]
       UpperCamelCase_							       =       convert_path_to_module(a__     )
       UpperCamelCase_							       =       str(solution_module.solution()     )  # type: ignore
       UpperCamelCase_							       =       hashlib.shaaaa(answer.encode()     ).hexdigest()
       assert (
           answer == expected
       ), f'''Expected solution to {problem_number} to have hash {expected}, got {answer}'''



