






"""simple docstring"""

import unittest
from unittest import skip

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow
from transformers.trainer_utils import set_seed


if is_torch_available():
					import torch

					from transformers import JukeboxModel, JukeboxPrior, JukeboxTokenizer


@require_torch
class 	__lowerCamelCase       (				unittest.TestCase    ):





		'''simple docstring'''






		a_			:       int      =							(JukeboxModel,) if is_torch_available() else ()
		a_			:       str      =							"""openai/jukebox-1b-lyrics"""
		a_			:       str      =							{
		    """artist""": """Zac Brown Band""",
		    """genres""": """Country""",
		    """lyrics""": """I met a traveller from an antique land,
    Who said \"Two vast and trunkless legs of stone
    Stand in the desert. . . . Near them, on the sand,
    Half sunk a shattered visage lies, whose frown,
    And wrinkled lip, and sneer of cold command,
    Tell that its sculptor well those passions read
    Which yet survive, stamped on these lifeless things,
    The hand that mocked them, and the heart that fed;
    And on the pedestal, these words appear:
    My name is Ozymandias, King of Kings;
    Look on my Works, ye Mighty, and despair!
    Nothing beside remains. Round the decay
    Of that colossal Wreck, boundless and bare
    The lone and level sands stretch far away
    """,
		}
		# fmt: off
		a_			:       Optional[Any]      =							[
		    1864, 1536, 1213, 1870, 1357, 1536, 519, 880, 1323, 789, 1082, 534,
		    1000, 1445, 1105, 1130, 967, 515, 1434, 1620, 534, 1495, 283, 1445,
		    333, 1307, 539, 1631, 1528, 375, 1434, 673, 627, 710, 778, 1883,
		    1405, 1276, 1455, 1228
		]

		a_			:       Dict      =							[
		    1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653
		]

		a_			:       List[str]      =							[
		    1125, 1751, 697, 1776, 1141, 1476, 391, 697, 1125, 684, 867, 416,
		    844, 1372, 1274, 717, 1274, 844, 1299, 1419, 697, 1370, 317, 1125,
		    191, 1440, 1370, 1440, 1370, 282, 1621, 1370, 368, 349, 867, 1872,
		    1262, 869, 1728, 747
		]
		a_			:       int      =							[
		    416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416
		]

		a_			:       Optional[int]      =							[
		    1755, 842, 307, 1843, 1022, 1395, 234, 1554, 806, 739, 1022, 442,
		    616, 556, 268, 1499, 933, 457, 1440, 1837, 755, 985, 308, 902,
		    293, 1443, 1671, 1141, 1533, 555, 1562, 1061, 287, 417, 1022, 2008,
		    1186, 1015, 1777, 268
		]
		a_			:       Union[str, Any]      =							[
		    854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842,
		    185, 417, 185, 842, 307, 842, 591, 842, 185, 842, 307, 842,
		    591, 842, 1353, 842, 185, 842, 591, 842, 591, 114, 591, 842,
		    185, 842, 591, 89
		]

		a_			:       Tuple      =							[105_8304, 0, 78_6432, 7169, 507, 76, 27, 40, 30, 76]

		a_			:       str      =							[
		    390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002,
		    1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002,
		    1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907,
		    1907, 1788, 596, 1626
		]
		a_			:       Any      =							[
		    1236, 1668, 1484, 1920, 1848, 1409, 139, 864, 1828, 1272, 1599, 824,
		    1672, 139, 555, 1484, 824, 1920, 555, 596, 1579, 1599, 1231, 1599,
		    1637, 1407, 212, 824, 1599, 116, 1433, 824, 258, 1599, 1433, 1895,
		    1063, 1433, 1433, 1599
		]
		a_			:       List[str]      =							[
		    1684, 1873, 1119, 1189, 395, 611, 1901, 972, 890, 1337, 1392, 1927,
		    96, 972, 672, 780, 1119, 890, 158, 771, 1073, 1927, 353, 1331,
		    1269, 1459, 1333, 1645, 812, 1577, 1337, 606, 353, 981, 1466, 619,
		    197, 391, 302, 1930
		]
		a_			:       str      =							[
		    390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002,
		    1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002,
		    1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907,
		    1907, 1788, 596, 1626
		]
		a_			:       Union[str, Any]      =							[
		    -0.04_92, -0.05_24, -0.05_65, -0.06_40, -0.06_86, -0.06_84, -0.06_77, -0.06_64,
		    -0.06_05, -0.04_90, -0.03_30, -0.01_68, -0.00_83, -0.00_75, -0.00_51, 0.00_25,
		    0.01_36, 0.02_61, 0.03_86, 0.04_97, 0.05_80, 0.05_99, 0.05_83, 0.06_14,
		    0.07_40, 0.08_89, 0.10_23, 0.11_62, 0.12_11, 0.12_12, 0.12_51, 0.13_36,
		    0.15_02, 0.16_86, 0.18_83, 0.21_48, 0.23_63, 0.24_58, 0.25_07, 0.25_31
		]
		a_			:       List[Any]      =							[
		    0.02_56, -0.05_44, 0.16_00, -0.00_32, 0.10_66, 0.08_25, -0.00_13, 0.34_40,
		    0.02_10, 0.04_12, -0.17_77, -0.08_92, -0.01_64, 0.02_85, -0.06_13, -0.06_17,
		    -0.01_37, -0.02_01, -0.01_75, 0.02_15, -0.06_27, 0.05_20, -0.07_30, 0.09_70,
		    -0.01_00, 0.04_42, -0.05_86, 0.02_07, -0.00_15, -0.00_82
		]
		a_			:       Optional[int]      =							[
		    0.04_15, 0.08_77, 0.00_22, -0.00_55, 0.07_51, 0.03_34, 0.03_24, -0.00_68,
		    0.00_11, 0.00_17, -0.06_76, 0.06_55, -0.01_43, 0.03_99, 0.03_03, 0.07_43,
		    -0.01_68, -0.03_94, -0.11_13, 0.01_24, 0.04_42, 0.02_67, -0.00_03, -0.15_36,
		    -0.01_16, -0.18_37, -0.01_80, -0.10_26, -0.07_77, -0.04_56
		]
		a_			:       Dict      =							[
		    76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33,
		    45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76
		]





		def      lowerCamelCase (     self							:			Dict			):
				lowerCAmelCase_     :							Dict             =    JukeboxTokenizer.from_pretrained(self.model_id			)
				lowerCAmelCase_     :							Optional[int]             =    tokenizer(**self.metas			)['''input_ids''']
				return tokens





		@slow
		def      lowerCamelCase (     self							:			List[Any]			):
				lowerCAmelCase_     :							List[str]             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()
				lowerCAmelCase_     :							List[Any]             =    self.prepare_inputs()

				set_seed(0			)
				lowerCAmelCase_     :							str             =    [torch.zeros(1		,    0		,    dtype=torch.long			).cpu() for _ in range(3			)]
				lowerCAmelCase_     :							List[Any]             =    model._sample(lowercase_		,    lowercase_		,    [0]		,    sample_length=40 * model.priors[0].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[0][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]			)

				set_seed(0			)
				lowerCAmelCase_     :							Any             =    model._sample(lowercase_		,    lowercase_		,    [1]		,    sample_length=40 * model.priors[1].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[1][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]			)

				set_seed(0			)
				lowerCAmelCase_     :							Tuple             =    model._sample(lowercase_		,    lowercase_		,    [2]		,    sample_length=40 * model.priors[2].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[2][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]			)





		@slow
		def      lowerCamelCase (     self							:			Optional[int]			):
				lowerCAmelCase_     :							List[Any]             =    False
				lowerCAmelCase_     :							int             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()

				lowerCAmelCase_     :							Tuple             =    self.prepare_inputs()
				set_seed(0			)
				lowerCAmelCase_     :							Optional[Any]             =    [torch.zeros(1		,    0		,    dtype=torch.long			) for _ in range(3			)]

				lowerCAmelCase_     :							List[str]             =    model.priors[0]
				lowerCAmelCase_     :							Optional[int]             =    0
				lowerCAmelCase_     :							Any             =    top_prior.get_music_tokens_conds(lowercase_		,    start=lowercase_		,    end=start + top_prior.n_ctx			)
				lowerCAmelCase_     :							str             =    top_prior.get_metadata(labels[0].clone()		,    lowercase_		,    1_05_83_04		,    0			)

				self.assertIsNone(lowercase_			)
				self.assertListEqual(metadata.numpy()[0][:10].tolist()		,    self.EXPECTED_Y_COND			)

				lowerCAmelCase_     :							Dict             =    top_prior.get_cond(lowercase_		,    lowercase_			)
				torch.testing.assert_allclose(
				    audio_conditioning[0][0][:30].detach()		,    torch.tensor(self.EXPECTED_AUDIO_COND			)		,    atol=1e-4		,    rtol=1e-4			)
				torch.testing.assert_allclose(
				    metadata_conditioning[0][0][:30].detach()		,    torch.tensor(self.EXPECTED_META_COND			)		,    atol=1e-4		,    rtol=1e-4			)
				torch.testing.assert_allclose(
				    lyric_tokens[0, :30].detach()		,    torch.tensor(self.EXPECTED_LYRIC_COND			)		,    atol=1e-4		,    rtol=1e-4			)





		@slow
		def      lowerCamelCase (     self							:			List[str]			):
				lowerCAmelCase_     :							str             =    False

				lowerCAmelCase_     :							Optional[Any]             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()
				set_seed(0			)
				lowerCAmelCase_     :							str             =    torch.rand((1, 51_20, 1)			)
				lowerCAmelCase_     :							Union[str, Any]             =    list(self.prepare_inputs()			)

				lowerCAmelCase_     :							int             =    [model.vqvae.encode(lowercase_		,    start_level=2		,    bs_chunks=waveform.shape[0]			)[0], None, None]
				lowerCAmelCase_     :							Optional[Any]             =    model._sample(
				    lowercase_		,    lowercase_		,    sample_levels=[0]		,    save_results=lowercase_		,    sample_length=40 * model.priors[0].raw_to_tokens			)
				torch.testing.assert_allclose(zs[0][0][:40]		,    torch.tensor(self.EXPECTED_PRIMED_0			)			)

				lowerCAmelCase_     :							List[Any]             =    torch.cat((zs[0], torch.zeros(1		,    20_48 - zs[0].shape[-1]			))		,    dim=-1			).long()
				lowerCAmelCase_     :							Dict             =    [upper_a, model.vqvae.encode(lowercase_		,    start_level=1		,    bs_chunks=waveform.shape[0]			)[0], None]
				lowerCAmelCase_     :							Optional[int]             =    model._sample(
				    lowercase_		,    lowercase_		,    sample_levels=[1]		,    save_results=lowercase_		,    sample_length=40 * model.priors[1].raw_to_tokens			)
				torch.testing.assert_allclose(zs[1][0][:40]		,    torch.tensor(self.EXPECTED_PRIMED_1			)			)

				lowerCAmelCase_     :							Any             =    torch.cat((zs[1], torch.zeros(1		,    20_48 - zs[1].shape[-1]			))		,    dim=-1			).long()
				lowerCAmelCase_     :							Optional[int]             =    [upper_a, upper_a, model.vqvae.encode(lowercase_		,    start_level=0		,    bs_chunks=waveform.shape[0]			)[0]]
				lowerCAmelCase_     :							List[str]             =    model._sample(
				    lowercase_		,    lowercase_		,    sample_levels=[2]		,    save_results=lowercase_		,    sample_length=40 * model.priors[2].raw_to_tokens			)
				torch.testing.assert_allclose(zs[2][0][:40].cpu()		,    torch.tensor(self.EXPECTED_PRIMED_2			)			)





		@slow
		def      lowerCamelCase (     self							:			str			):
				lowerCAmelCase_     :							str             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()
				set_seed(0			)
				lowerCAmelCase_     :							str             =    torch.rand((1, 51_20, 1)			)
				with torch.no_grad():
						lowerCAmelCase_     :							Dict             =    model.vqvae.encode(lowercase_		,    start_level=2		,    bs_chunks=x.shape[0]			)
				torch.testing.assert_allclose(zs[0][0]		,    torch.tensor(self.EXPECTED_VQVAE_ENCODE			)			)

				with torch.no_grad():
						lowerCAmelCase_     :							Dict             =    model.vqvae.decode(lowercase_		,    start_level=2		,    bs_chunks=x.shape[0]			)
				torch.testing.assert_allclose(x[0, :40, 0]		,    torch.tensor(self.EXPECTED_VQVAE_DECODE			)		,    atol=1e-4		,    rtol=1e-4			)







@require_torch
class 	__lowerCamelCase       (				unittest.TestCase    ):





		'''simple docstring'''






		a_			:       Dict      =							(JukeboxModel,) if is_torch_available() else ()
		a_			:       str      =							"""openai/jukebox-5b-lyrics"""
		a_			:       List[str]      =							{
		    """artist""": """Zac Brown Band""",
		    """genres""": """Country""",
		    """lyrics""": """I met a traveller from an antique land,
    Who said \"Two vast and trunkless legs of stone
    Stand in the desert. . . . Near them, on the sand,
    Half sunk a shattered visage lies, whose frown,
    And wrinkled lip, and sneer of cold command,
    Tell that its sculptor well those passions read
    Which yet survive, stamped on these lifeless things,
    The hand that mocked them, and the heart that fed;
    And on the pedestal, these words appear:
    My name is Ozymandias, King of Kings;
    Look on my Works, ye Mighty, and despair!
    Nothing beside remains. Round the decay
    Of that colossal Wreck, boundless and bare
    The lone and level sands stretch far away
    """,
		}

		# fmt: off
		a_			:       Tuple      =							[
		    1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    1489, 1489, 1489, 1489, 1150, 1853, 1509, 1150, 1357, 1509, 6, 1272
		]
		a_			:       List[Any]      =							[
		    1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653
		]

		a_			:       Optional[Any]      =							[
		    1125, 416, 1125, 1125, 1125, 1125, 1125, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416
		]
		a_			:       Dict      =							[
		    416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416
		]

		a_			:       Union[str, Any]      =							[
		    1755, 1061, 234, 1755, 1061, 1755, 185, 290, 307, 307, 616, 616,
		    616, 616, 616, 616, 307, 290, 417, 1755, 234, 1755, 185, 290,
		    290, 290, 307, 616, 616, 616, 616, 616, 290, 234, 234, 1755,
		    234, 234, 1755, 234, 185, 185, 307, 616, 616, 616, 616, 290,
		    1755, 1755, 1755, 234, 234, 1755, 1572, 290, 307, 616, 34, 616
		]
		a_			:       str      =							[
		    854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842, 185,
		    417, 185, 842, 307, 842, 591, 842, 185, 842, 185, 842, 591, 842,
		    1353, 842, 185, 842, 591, 842, 591, 114, 591, 842, 185, 842, 591,
		    89, 591, 842, 591, 842, 591, 417, 1372, 842, 1372, 842, 34, 842,
		    185, 89, 591, 842, 185, 842, 591, 632
		]

		a_			:       Optional[int]      =							[
		    1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653
		]
		a_			:       Optional[Any]      =							[
		    1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
		    653, 653, 653, 653, 653, 653, 653, 1853, 1177, 1536, 1228,
		    710, 475, 1489, 1229, 1224, 231, 1224, 252, 1434, 653, 475,
		    1106, 1877, 1599, 1228, 1600, 1683, 1182, 1853, 475, 1864,
		    252, 1229, 1434, 2001
		]

		a_			:       Optional[int]      =							[
		    1125, 1125, 416, 1125, 1125, 416, 1125, 1125, 416, 416, 1125, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416,
		    416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416
		]
		a_			:       Tuple      =							[
		    491, 1755, 34, 1613, 1755, 417, 992, 1613, 222, 842, 1353, 1613,
		    844, 632, 185, 1613, 844, 632, 185, 1613, 185, 842, 677, 1613,
		    185, 114, 1353, 1613, 307, 89, 844, 1613, 307, 1332, 234, 1979,
		    307, 89, 1353, 616, 34, 842, 185, 842, 34, 842, 185, 842,
		    307, 114, 185, 89, 34, 1268, 185, 89, 34, 842, 185, 89
		]





		def      lowerCamelCase (     self							:			Dict		,    a_							:			List[Any]			):
				lowerCAmelCase_     :							Optional[Any]             =    JukeboxTokenizer.from_pretrained(lowercase_			)
				lowerCAmelCase_     :							Union[str, Any]             =    tokenizer(**self.metas			)['''input_ids''']
				return tokens





		@slow
		def      lowerCamelCase (     self							:			Optional[Any]			):
				lowerCAmelCase_     :							List[str]             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()
				lowerCAmelCase_     :							List[str]             =    self.prepare_inputs(self.model_id			)

				set_seed(0			)
				lowerCAmelCase_     :							Optional[Any]             =    [torch.zeros(1		,    0		,    dtype=torch.long			).cpu() for _ in range(3			)]
				lowerCAmelCase_     :							str             =    model._sample(lowercase_		,    lowercase_		,    [0]		,    sample_length=60 * model.priors[0].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[0][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]			)

				set_seed(0			)
				lowerCAmelCase_     :							Dict             =    model._sample(lowercase_		,    lowercase_		,    [1]		,    sample_length=60 * model.priors[1].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[1][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]			)

				set_seed(0			)
				lowerCAmelCase_     :							int             =    model._sample(lowercase_		,    lowercase_		,    [2]		,    sample_length=60 * model.priors[2].raw_to_tokens		,    save_results=lowercase_			)
				self.assertIn(zs[2][0].detach().cpu().tolist()		,    [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]			)





		@slow
		@skip("Not enough GPU memory on CI runners"			)
		def      lowerCamelCase (     self							:			int			):
				lowerCAmelCase_     :							Tuple             =    JukeboxModel.from_pretrained(self.model_id		,    min_duration=0			).eval()
				lowerCAmelCase_     :							Union[str, Any]             =    [i.cuda() for i in self.prepare_inputs(self.model_id			)]

				set_seed(0			)
				model.priors[0].cuda()
				lowerCAmelCase_     :							List[Any]             =    [torch.zeros(1		,    0		,    dtype=torch.long			).cuda() for _ in range(3			)]
				lowerCAmelCase_     :							str             =    model._sample(lowercase_		,    lowercase_		,    [0]		,    sample_length=60 * model.priors[0].raw_to_tokens		,    save_results=lowercase_			)
				torch.testing.assert_allclose(zs[0][0].cpu()		,    torch.tensor(self.EXPECTED_GPU_OUTPUTS_2			)			)
				model.priors[0].cpu()

				set_seed(0			)
				model.priors[1].cuda()
				lowerCAmelCase_     :							Tuple             =    model._sample(lowercase_		,    lowercase_		,    [1]		,    sample_length=60 * model.priors[1].raw_to_tokens		,    save_results=lowercase_			)
				torch.testing.assert_allclose(zs[1][0].cpu()		,    torch.tensor(self.EXPECTED_GPU_OUTPUTS_1			)			)
				model.priors[1].cpu()

				set_seed(0			)
				model.priors[2].cuda()
				lowerCAmelCase_     :							List[str]             =    model._sample(lowercase_		,    lowercase_		,    [2]		,    sample_length=60 * model.priors[2].raw_to_tokens		,    save_results=lowercase_			)
				torch.testing.assert_allclose(zs[2][0].cpu()		,    torch.tensor(self.EXPECTED_GPU_OUTPUTS_0			)			)





		@slow
		def      lowerCamelCase (     self							:			Union[str, Any]			):
				lowerCAmelCase_     :							Any             =    '''ArthurZ/jukebox_prior_0'''
				lowerCAmelCase_     :							str             =    JukeboxPrior.from_pretrained(lowercase_		,    min_duration=0			).eval().half().to("cuda"			)

				lowerCAmelCase_     :							Union[str, Any]             =    self.prepare_inputs(lowercase_			)[0].cuda()
				lowerCAmelCase_     :							int             =    model.get_metadata(lowercase_		,    0		,    76_80		,    0			)
				set_seed(0			)
				lowerCAmelCase_     :							List[str]             =    model.sample(1		,    metadata=lowercase_		,    sample_tokens=60			)
				self.assertIn(outputs[0].cpu().tolist()		,    [self.EXPECTED_GPU_OUTPUTS_2, self.EXPECTED_GPU_OUTPUTS_2_PT_2]			)














"""simple docstring"""

import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 	__lowerCamelCase       (				A__				,							unittest.TestCase    ):





		'''simple docstring'''






		a_			:       List[str]      =							RealmTokenizer
		a_			:       int      =							RealmTokenizerFast
		a_			:       str      =							True
		a_			:       Tuple      =							True
		a_			:       List[Any]      =							filter_non_english





		def      lowerCamelCase (     self							:			int			):
				super().setUp()

				lowerCAmelCase_     :							int             =    [
				    "[UNK]",
				    "[CLS]",
				    "[SEP]",
				    "[PAD]",
				    "[MASK]",
				    "want",
				    "##want",
				    "##ed",
				    "wa",
				    "un",
				    "runn",
				    "##ing",
				    ",",
				    "low",
				    "lowest",
				]
				lowerCAmelCase_     :							List[Any]             =    os.path.join(self.tmpdirname		,    VOCAB_FILES_NAMES["vocab_file"]			)
				with open(self.vocab_file		,    "w"		,    encoding="utf-8"			) as vocab_writer:
						vocab_writer.write("".join([x + "\n" for x in vocab_tokens]			)			)





		def      lowerCamelCase (     self							:			Optional[int]		,    a_							:			Any			):
				lowerCAmelCase_     :							int             =    "UNwant\u00E9d,running"
				lowerCAmelCase_     :							Optional[Any]             =    "unwanted, running"
				return input_text, output_text





		def      lowerCamelCase (     self							:			int			):
				lowerCAmelCase_     :							Tuple             =    self.tokenizer_class(self.vocab_file			)

				lowerCAmelCase_     :							List[str]             =    tokenizer.tokenize("UNwant\u00E9d,running"			)
				self.assertListEqual(a_		,    ["un", "##want", "##ed", ",", "runn", "##ing"]			)
				self.assertListEqual(tokenizer.convert_tokens_to_ids(a_			)		,    [9, 6, 7, 12, 10, 11]			)





		def      lowerCamelCase (     self							:			Dict			):
				if not self.test_rust_tokenizer:
						return

				lowerCAmelCase_     :							str             =    self.get_tokenizer()
				lowerCAmelCase_     :							List[str]             =    self.get_rust_tokenizer()

				lowerCAmelCase_     :							Optional[Any]             =    "UNwant\u00E9d,running"

				lowerCAmelCase_     :							Optional[Any]             =    tokenizer.tokenize(a_			)
				lowerCAmelCase_     :							List[Any]             =    rust_tokenizer.tokenize(a_			)
				self.assertListEqual(a_		,    a_			)

				lowerCAmelCase_     :							str             =    tokenizer.encode(a_		,    add_special_tokens=a_			)
				lowerCAmelCase_     :							Dict             =    rust_tokenizer.encode(a_		,    add_special_tokens=a_			)
				self.assertListEqual(a_		,    a_			)

				lowerCAmelCase_     :							int             =    self.get_rust_tokenizer()
				lowerCAmelCase_     :							Any             =    tokenizer.encode(a_			)
				lowerCAmelCase_     :							Union[str, Any]             =    rust_tokenizer.encode(a_			)
				self.assertListEqual(a_		,    a_			)

				# With lower casing
				lowerCAmelCase_     :							Dict             =    self.get_tokenizer(do_lower_case=a_			)
				lowerCAmelCase_     :							List[str]             =    self.get_rust_tokenizer(do_lower_case=a_			)

				lowerCAmelCase_     :							Dict             =    "UNwant\u00E9d,running"

				lowerCAmelCase_     :							Union[str, Any]             =    tokenizer.tokenize(a_			)
				lowerCAmelCase_     :							Union[str, Any]             =    rust_tokenizer.tokenize(a_			)
				self.assertListEqual(a_		,    a_			)

				lowerCAmelCase_     :							Optional[Any]             =    tokenizer.encode(a_		,    add_special_tokens=a_			)
				lowerCAmelCase_     :							Dict             =    rust_tokenizer.encode(a_		,    add_special_tokens=a_			)
				self.assertListEqual(a_		,    a_			)

				lowerCAmelCase_     :							str             =    self.get_rust_tokenizer()
				lowerCAmelCase_     :							str             =    tokenizer.encode(a_			)
				lowerCAmelCase_     :							Optional[int]             =    rust_tokenizer.encode(a_			)
				self.assertListEqual(a_		,    a_			)





		def      lowerCamelCase (     self							:			Optional[int]			):
				lowerCAmelCase_     :							Any             =    BasicTokenizer()

				self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"			)		,    ["ah", "\u535A", "\u63A8", "zz"]			)





		def      lowerCamelCase (     self							:			Tuple			):
				lowerCAmelCase_     :							Dict             =    BasicTokenizer(do_lower_case=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "			)		,    ["hello", "!", "how", "are", "you", "?"]			)
				self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)		,    ["hello"]			)





		def      lowerCamelCase (     self							:			Optional[Any]			):
				lowerCAmelCase_     :							Optional[int]             =    BasicTokenizer(do_lower_case=a_		,    strip_accents=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)		,    ["hällo", "!", "how", "are", "you", "?"]			)
				self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)		,    ["h\u00E9llo"]			)





		def      lowerCamelCase (     self							:			Tuple			):
				lowerCAmelCase_     :							Dict             =    BasicTokenizer(do_lower_case=a_		,    strip_accents=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)		,    ["hallo", "!", "how", "are", "you", "?"]			)
				self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)		,    ["hello"]			)





		def      lowerCamelCase (     self							:			str			):
				lowerCAmelCase_     :							List[Any]             =    BasicTokenizer(do_lower_case=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)		,    ["hallo", "!", "how", "are", "you", "?"]			)
				self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)		,    ["hello"]			)





		def      lowerCamelCase (     self							:			List[Any]			):
				lowerCAmelCase_     :							Optional[Any]             =    BasicTokenizer(do_lower_case=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "			)		,    ["HeLLo", "!", "how", "Are", "yoU", "?"]			)





		def      lowerCamelCase (     self							:			List[Any]			):
				lowerCAmelCase_     :							List[Any]             =    BasicTokenizer(do_lower_case=a_		,    strip_accents=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)		,    ["HäLLo", "!", "how", "Are", "yoU", "?"]			)





		def      lowerCamelCase (     self							:			Dict			):
				lowerCAmelCase_     :							List[str]             =    BasicTokenizer(do_lower_case=a_		,    strip_accents=a_			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)		,    ["HaLLo", "!", "how", "Are", "yoU", "?"]			)





		def      lowerCamelCase (     self							:			List[str]			):
				lowerCAmelCase_     :							Any             =    BasicTokenizer(do_lower_case=a_		,    never_split=["[UNK]"]			)

				self.assertListEqual(
				    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"			)		,    ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]			)





		def      lowerCamelCase (     self							:			Optional[Any]			):
				lowerCAmelCase_     :							int             =    ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

				lowerCAmelCase_     :							Union[str, Any]             =    {}
				for i, token in enumerate(a_			):
						lowerCAmelCase_     :							Any             =    i
				lowerCAmelCase_     :							int             =    WordpieceTokenizer(vocab=a_		,    unk_token="[UNK]"			)

				self.assertListEqual(tokenizer.tokenize(""			)		,    []			)

				self.assertListEqual(tokenizer.tokenize("unwanted running"			)		,    ["un", "##want", "##ed", "runn", "##ing"]			)

				self.assertListEqual(tokenizer.tokenize("unwantedX running"			)		,    ["[UNK]", "runn", "##ing"]			)





		def      lowerCamelCase (     self							:			Tuple			):
				self.assertTrue(_is_whitespace(" "			)			)
				self.assertTrue(_is_whitespace("\t"			)			)
				self.assertTrue(_is_whitespace("\r"			)			)
				self.assertTrue(_is_whitespace("\n"			)			)
				self.assertTrue(_is_whitespace("\u00A0"			)			)

				self.assertFalse(_is_whitespace("A"			)			)
				self.assertFalse(_is_whitespace("-"			)			)





		def      lowerCamelCase (     self							:			Optional[Any]			):
				self.assertTrue(_is_control("\u0005"			)			)

				self.assertFalse(_is_control("A"			)			)
				self.assertFalse(_is_control(" "			)			)
				self.assertFalse(_is_control("\t"			)			)
				self.assertFalse(_is_control("\r"			)			)





		def      lowerCamelCase (     self							:			str			):
				self.assertTrue(_is_punctuation("-"			)			)
				self.assertTrue(_is_punctuation("$"			)			)
				self.assertTrue(_is_punctuation("`"			)			)
				self.assertTrue(_is_punctuation("."			)			)

				self.assertFalse(_is_punctuation("A"			)			)
				self.assertFalse(_is_punctuation(" "			)			)





		def      lowerCamelCase (     self							:			str			):
				lowerCAmelCase_     :							Any             =    self.get_tokenizer()

				# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
				self.assertListEqual([tokenizer.tokenize(a_			) for t in ["Test", "\xad", "test"]]		,    [["[UNK]"], [], ["[UNK]"]]			)

				if self.test_rust_tokenizer:
						lowerCAmelCase_     :							str             =    self.get_rust_tokenizer()
						self.assertListEqual(
						    [rust_tokenizer.tokenize(a_			) for t in ["Test", "\xad", "test"]]		,    [["[UNK]"], [], ["[UNK]"]]			)





		@slow
		def      lowerCamelCase (     self							:			int			):
				lowerCAmelCase_     :							int             =    self.tokenizer_class.from_pretrained("bert-base-uncased"			)

				lowerCAmelCase_     :							List[Any]             =    tokenizer.encode("sequence builders"		,    add_special_tokens=a_			)
				lowerCAmelCase_     :							Optional[int]             =    tokenizer.encode("multi-sequence build"		,    add_special_tokens=a_			)

				lowerCAmelCase_     :							Dict             =    tokenizer.build_inputs_with_special_tokens(a_			)
				lowerCAmelCase_     :							Tuple             =    tokenizer.build_inputs_with_special_tokens(a_		,    a_			)

				assert encoded_sentence == [1_01] + text + [1_02]
				assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]





		def      lowerCamelCase (     self							:			Optional[int]			):
				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
								lowerCAmelCase_     :							Tuple             =    self.rust_tokenizer_class.from_pretrained(a_		,    **a_			)

								lowerCAmelCase_     :							Tuple             =    f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
								lowerCAmelCase_     :							List[str]             =    tokenizer_r.encode_plus(
								    a_		,    return_attention_mask=a_		,    return_token_type_ids=a_		,    return_offsets_mapping=a_		,    add_special_tokens=a_		,    )

								lowerCAmelCase_     :							List[str]             =    tokenizer_r.do_lower_case if hasattr(a_		,    "do_lower_case"			) else False
								lowerCAmelCase_     :							int             =    (
								    [
								        ((0, 0), tokenizer_r.cls_token),
								        ((0, 1), "A"),
								        ((1, 2), ","),
								        ((3, 5), "na"),
								        ((5, 6), "##ï"),
								        ((6, 8), "##ve"),
								        ((9, 15), tokenizer_r.mask_token),
								        ((16, 21), "Allen"),
								        ((21, 23), "##NL"),
								        ((23, 24), "##P"),
								        ((25, 33), "sentence"),
								        ((33, 34), "."),
								        ((0, 0), tokenizer_r.sep_token),
								    ]
								    if not do_lower_case
								    else [
								        ((0, 0), tokenizer_r.cls_token),
								        ((0, 1), "a"),
								        ((1, 2), ","),
								        ((3, 8), "naive"),
								        ((9, 15), tokenizer_r.mask_token),
								        ((16, 21), "allen"),
								        ((21, 23), "##nl"),
								        ((23, 24), "##p"),
								        ((25, 33), "sentence"),
								        ((33, 34), "."),
								        ((0, 0), tokenizer_r.sep_token),
								    ]
								)

								self.assertEqual(
								    [e[1] for e in expected_results]		,    tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]			)			)
								self.assertEqual([e[0] for e in expected_results]		,    tokens["offset_mapping"]			)





		@slow
		def      lowerCamelCase (     self							:			int			):
				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
								lowerCAmelCase_     :							Tuple             =    self.rust_tokenizer_class.from_pretrained(a_		,    **a_			)
								lowerCAmelCase_     :							Tuple             =    self.tokenizer_class.from_pretrained(a_		,    **a_			)
								lowerCAmelCase_     :							Dict             =    [["Hello world!", "Nice to meet you!"], ["The cute cat.", "The adorable dog."]]

								lowerCAmelCase_     :							Optional[Any]             =    tokenizer_r.batch_encode_candidates(a_		,    max_length=10		,    return_tensors="np"			)
								lowerCAmelCase_     :							int             =    tokenizer_p.batch_encode_candidates(a_		,    max_length=10		,    return_tensors="np"			)

								lowerCAmelCase_     :							Dict             =    (2, 2, 10)

								self.assertEqual(encoded_sentence_r["input_ids"].shape		,    a_			)
								self.assertEqual(encoded_sentence_r["attention_mask"].shape		,    a_			)
								self.assertEqual(encoded_sentence_r["token_type_ids"].shape		,    a_			)

								self.assertEqual(encoded_sentence_p["input_ids"].shape		,    a_			)
								self.assertEqual(encoded_sentence_p["attention_mask"].shape		,    a_			)
								self.assertEqual(encoded_sentence_p["token_type_ids"].shape		,    a_			)
