





import argparse
import os


UpperCamelCase__ :			int       	=			{
    """pytorch""": {
        """1.13""": {
            """torch""": """1.13.1""",
            """torchvision""": """0.14.1""",
            """torchaudio""": """0.13.1""",
            """python""": 3.9,
            """cuda""": """cu116""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu116"""
            ),
            """base_image""": """nvidia/cuda:11.6.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.12""": {
            """torch""": """1.12.1""",
            """torchvision""": """0.13.1""",
            """torchaudio""": """0.12.1""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.11""": {
            """torch""": """1.11.0""",
            """torchvision""": """0.12.0""",
            """torchaudio""": """0.11.0""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.10""": {
            """torch""": """1.10.2""",
            """torchvision""": """0.11.3""",
            """torchaudio""": """0.10.2""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.10.2 torchvision==0.11.3 torchaudio==0.10.2"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        # torchaudio < 0.10 has no CUDA-enabled binary distributions
        """1.9""": {
            """torch""": """1.9.1""",
            """torchvision""": """0.10.1""",
            """torchaudio""": """0.9.1""",
            """python""": 3.9,
            """cuda""": """cu111""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.9.1 torchvision==0.10.1 torchaudio==0.9.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu111"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
    },
    """tensorflow""": {
        """2.11""": {
            """tensorflow""": """2.11.1""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.11.1""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.10""": {
            """tensorflow""": """2.10.1""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.10.1""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.9""": {
            """tensorflow""": """2.9.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.9.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.8""": {
            """tensorflow""": """2.8.2""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.8.2""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.7""": {
            """tensorflow""": """2.7.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.7.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.6""": {
            """tensorflow""": """2.6.5""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.6.5""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.5""": {
            """tensorflow""": """2.5.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.5.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
    },
}


if __name__ == "__main__":
				UpperCamelCase__ :			Optional[int]       	=			argparse.ArgumentParser("""Choose the framework and version to install""")
				parser.add_argument(
				    """--framework""", help="""The framework to install. Should be `torch` or `tensorflow`""", type=str, required=True
				)
				parser.add_argument("""--version""", help="""The version of the framework to install.""", type=str, required=True)
				UpperCamelCase__ :			Optional[Any]       	=			parser.parse_args()

				UpperCamelCase__ :			List[Any]       	=			past_versions_testing[args.framework][args.version]

				os.system(f"echo \"export INSTALL_CMD=\'{info['install']}\'\" >> ~/.profile")
				print(f"echo \"export INSTALL_CMD=\'{info['install']}\'\" >> ~/.profile")

				UpperCamelCase__ :			List[str]       	=			""""""
				if args.framework == "pytorch":
								UpperCamelCase__ :			Tuple       	=			info["""cuda"""]
				os.system(f"echo \"export CUDA='{cuda}'\" >> ~/.profile")
				print(f"echo \"export CUDA='{cuda}'\" >> ~/.profile")








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

      UpperCAmelCase__ :      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
      ]

      UpperCAmelCase__ :      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
      ]
      UpperCAmelCase__ :      str       						=  [
          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
      ]

      UpperCAmelCase__ :      str       						=  [
          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
      ]
      UpperCAmelCase__ :      Tuple       						=  [
          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
      ]

      UpperCAmelCase__ :      List[Any]       						=  [105_8304, 0, 78_6432, 7169, 507, 76, 27, 40, 30, 76]

      UpperCAmelCase__ :      Union[str, Any]       						=  [
          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
      ]
      UpperCAmelCase__ :      List[str]       						=  [
          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
      ]
      UpperCAmelCase__ :      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
      ]
      UpperCAmelCase__ :      Union[str, Any]       						=  [
          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
      ]
      UpperCAmelCase__ :      Optional[int]       						=  [
          -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
      ]
      UpperCAmelCase__ :      Union[str, 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
      ]
      UpperCAmelCase__ :      str       						=  [
          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
      ]
      UpperCAmelCase__ :      int       						=  [
          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  =		JukeboxTokenizer.from_pretrained(self.model_id  )
             __lowerCamelCase  =		tokenizer(**self.metas  )["""input_ids"""]
             return tokens
      @slow
      def      lowerCAmelCase__		(							self:					Union[str, Any]  ):
             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()
             __lowerCamelCase  =		self.prepare_inputs()

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

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

             set_seed(0  )
             __lowerCamelCase  =		model._sample(UpperCamelCase_       ,			UpperCamelCase_       ,			[2]       ,			sample_length=40 * model.priors[2].raw_to_tokens       ,			save_results=UpperCamelCase_  )
             self.assertIn(zs[2][0].detach().cpu().tolist()       ,			[self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]  )
      @slow
      def      lowerCAmelCase__		(							self:					Union[str, Any]  ):
             __lowerCamelCase  =		False
             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()

             __lowerCamelCase  =		self.prepare_inputs()
             set_seed(0  )
             __lowerCamelCase  =		[torch.zeros(1       ,			0       ,			dtype=torch.long  ) for _ in range(3  )]

             __lowerCamelCase  =		model.priors[0]
             __lowerCamelCase  =		0
             __lowerCamelCase  =		top_prior.get_music_tokens_conds(UpperCamelCase_       ,			start=UpperCamelCase_       ,			end=start + top_prior.n_ctx  )
             __lowerCamelCase  =		top_prior.get_metadata(labels[0].clone()       ,			UpperCamelCase_       ,			1_05_83_04       ,			0  )

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

             __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase  =		top_prior.get_cond(UpperCamelCase_       ,			UpperCamelCase_  )
             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[Any]  ):
             __lowerCamelCase  =		False

             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()
             set_seed(0  )
             __lowerCamelCase  =		torch.rand((1, 51_20, 1)  )
             __lowerCamelCase  =		list(self.prepare_inputs()  )

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

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

             __lowerCamelCase  =		torch.cat((zs[1], torch.zeros(1       ,			20_48 - zs[1].shape[-1]  ))       ,			dim=-1  ).long()
             __lowerCamelCase  =		[upper_a, upper_a, model.vqvae.encode(UpperCamelCase_       ,			start_level=0       ,			bs_chunks=waveform.shape[0]  )[0]]
             __lowerCamelCase  =		model._sample(
                 UpperCamelCase_       ,			UpperCamelCase_       ,			sample_levels=[2]       ,			save_results=UpperCamelCase_       ,			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:					List[Any]  ):
             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()
             set_seed(0  )
             __lowerCamelCase  =		torch.rand((1, 51_20, 1)  )
             with torch.no_grad():
                    __lowerCamelCase  =		model.vqvae.encode(UpperCamelCase_       ,			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  =		model.vqvae.decode(UpperCamelCase_       ,			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):
      UpperCAmelCase__ :      List[Any]       						=  (JukeboxModel,) if is_torch_available() else ()
      UpperCAmelCase__ :      Optional[int]       						=  'openai/jukebox-5b-lyrics'
      UpperCAmelCase__ :      Optional[Any]       						=  {
          'artist': 'Zac Brown Band',
          'genres': 'Country',
          'lyrics': 'I met a traveller from an antique land,\n    Who said "Two vast and trunkless legs of stone\n    Stand in the desert. . . . Near them, on the sand,\n    Half sunk a shattered visage lies, whose frown,\n    And wrinkled lip, and sneer of cold command,\n    Tell that its sculptor well those passions read\n    Which yet survive, stamped on these lifeless things,\n    The hand that mocked them, and the heart that fed;\n    And on the pedestal, these words appear:\n    My name is Ozymandias, King of Kings;\n    Look on my Works, ye Mighty, and despair!\n    Nothing beside remains. Round the decay\n    Of that colossal Wreck, boundless and bare\n    The lone and level sands stretch far away\n    ',
      }

      # fmt: off
      UpperCAmelCase__ :      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,
          1489, 1489, 1489, 1489, 1150, 1853, 1509, 1150, 1357, 1509, 6, 1272
      ]
      UpperCAmelCase__ :      Union[str, 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
      ]

      UpperCAmelCase__ :      Optional[int]       						=  [
          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
      ]
      UpperCAmelCase__ :      List[str]       						=  [
          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
      ]

      UpperCAmelCase__ :      Optional[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
      ]
      UpperCAmelCase__ :      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
      ]

      UpperCAmelCase__ :      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
      ]
      UpperCAmelCase__ :      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, 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
      ]

      UpperCAmelCase__ :      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
      ]
      UpperCAmelCase__ :      str       						=  [
          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:					Optional[Any]       ,			UpperCamelCase_:					Optional[int]  ):
             __lowerCamelCase  =		JukeboxTokenizer.from_pretrained(UpperCamelCase_  )
             __lowerCamelCase  =		tokenizer(**self.metas  )["""input_ids"""]
             return tokens
      @slow
      def      lowerCAmelCase__		(							self:					Tuple  ):
             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()
             __lowerCamelCase  =		self.prepare_inputs(self.model_id  )

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

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

             set_seed(0  )
             __lowerCamelCase  =		model._sample(UpperCamelCase_       ,			UpperCamelCase_       ,			[2]       ,			sample_length=60 * model.priors[2].raw_to_tokens       ,			save_results=UpperCamelCase_  )
             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:					List[Any]  ):
             __lowerCamelCase  =		JukeboxModel.from_pretrained(self.model_id       ,			min_duration=0  ).eval()
             __lowerCamelCase  =		[i.cuda() for i in self.prepare_inputs(self.model_id  )]

             set_seed(0  )
             model.priors[0].cuda()
             __lowerCamelCase  =		[torch.zeros(1       ,			0       ,			dtype=torch.long  ).cuda() for _ in range(3  )]
             __lowerCamelCase  =		model._sample(UpperCamelCase_       ,			UpperCamelCase_       ,			[0]       ,			sample_length=60 * model.priors[0].raw_to_tokens       ,			save_results=UpperCamelCase_  )
             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  =		model._sample(UpperCamelCase_       ,			UpperCamelCase_       ,			[1]       ,			sample_length=60 * model.priors[1].raw_to_tokens       ,			save_results=UpperCamelCase_  )
             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  =		model._sample(UpperCamelCase_       ,			UpperCamelCase_       ,			[2]       ,			sample_length=60 * model.priors[2].raw_to_tokens       ,			save_results=UpperCamelCase_  )
             torch.testing.assert_allclose(zs[2][0].cpu()       ,			torch.tensor(self.EXPECTED_GPU_OUTPUTS_0  )  )




      @slow
      def      lowerCAmelCase__		(							self:					Dict  ):
             __lowerCamelCase  =		"""ArthurZ/jukebox_prior_0"""
             __lowerCamelCase  =		JukeboxPrior.from_pretrained(UpperCamelCase_       ,			min_duration=0  ).eval().half().to("""cuda"""  )

             __lowerCamelCase  =		self.prepare_inputs(UpperCamelCase_  )[0].cuda()
             __lowerCamelCase  =		model.get_metadata(UpperCamelCase_       ,			0       ,			76_80       ,			0  )
             set_seed(0  )
             __lowerCamelCase  =		model.sample(1       ,			metadata=UpperCamelCase_       ,			sample_tokens=60  )
             self.assertIn(outputs[0].cpu().tolist()       ,			[self.EXPECTED_GPU_OUTPUTS_2, self.EXPECTED_GPU_OUTPUTS_2_PT_2]  )

