






'''simple docstring'''




import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
		import torch


__lowerCamelCase :       List[str] 				=       random.Random()

def 						__UpperCAmelCase							(			__magic_name__  ,__magic_name__=1.0  ,__magic_name__=None  ,__magic_name__=None    )->     List[Any]:



			"""simple docstring"""



			if rng is None:
						snake_case_					:       Optional[Any] =							global_rng

			snake_case_					:       Optional[Any] =							[]
			for batch_idx in range(shape[0]    ):
						values.append([]    )
						for _ in range(shape[1]    ):
									values[-1].append(rng.random() * scale    )

			return values







@require_torch
class  A_						(unittest.TestCase				):
							"""simple docstring"""




							def __init__(		self      :Dict							,				lowerCAmelCase__      :List[str]							,				lowerCAmelCase__      :Dict=7							,				lowerCAmelCase__      :Optional[Any]=400							,				lowerCAmelCase__      :Dict=2_000							,				lowerCAmelCase__      :int=1							,				lowerCAmelCase__      :Optional[int]=0.0							,				lowerCAmelCase__      :Dict=16_000							,				lowerCAmelCase__      :Dict=True							,				lowerCAmelCase__      :List[Any]=80							,				lowerCAmelCase__      :Dict=16							,				lowerCAmelCase__      :Union[str, Any]=64							,				lowerCAmelCase__      :Union[str, Any]="hann_window"							,				lowerCAmelCase__      :Optional[int]=80							,				lowerCAmelCase__      :Dict=7_600							,				lowerCAmelCase__      :Any=1E-1_0							,				lowerCAmelCase__      :Optional[int]=True							,				)					->	List[str]:


										'''simple docstring'''




										snake_case_					:       Optional[Any] =							parent
										snake_case_					:       int =							batch_size
										snake_case_					:       Union[str, Any] =							min_seq_length
										snake_case_					:       Any =							max_seq_length
										snake_case_					:       Optional[Any] =							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										snake_case_					:       List[str] =							feature_size
										snake_case_					:       List[str] =							padding_value
										snake_case_					:       int =							sampling_rate
										snake_case_					:       Union[str, Any] =							do_normalize
										snake_case_					:       Optional[Any] =							num_mel_bins
										snake_case_					:       Optional[int] =							hop_length
										snake_case_					:       Tuple =							win_length
										snake_case_					:       Optional[Any] =							win_function
										snake_case_					:       Any =							fmin
										snake_case_					:       int =							fmax
										snake_case_					:       str =							mel_floor
										snake_case_					:       Any =							return_attention_mask

							def 				_A						(		self      :Union[str, Any]					)					->	Optional[Any]:


										'''simple docstring'''




										return {
										    "feature_size": self.feature_size,
										    "padding_value": self.padding_value,
										    "sampling_rate": self.sampling_rate,
										    "do_normalize": self.do_normalize,
										    "num_mel_bins": self.num_mel_bins,
										    "hop_length": self.hop_length,
										    "win_length": self.win_length,
										    "win_function": self.win_function,
										    "fmin": self.fmin,
										    "fmax": self.fmax,
										    "mel_floor": self.mel_floor,
										    "return_attention_mask": self.return_attention_mask,
										}

							def 				_A						(		self      :Dict							,				lowerCAmelCase__      :Optional[int]=False							,				lowerCAmelCase__      :List[Any]=False					)					->	str:


										'''simple docstring'''




										def _flatten(lowerCAmelCase__      :Optional[int]					):
													return list(itertools.chain(*lowerCAmelCase__					)					)

										if equal_length:
													snake_case_					:       Optional[int] =							floats_list((self.batch_size, self.max_seq_length)					)
										else:
													# make sure that inputs increase in size
													snake_case_					:       Any =							[
													    _flatten(floats_list((x, self.feature_size)					)					)
													    for x in range(self.min_seq_length							,				self.max_seq_length							,				self.seq_length_diff					)
													]

										if numpify:
													snake_case_					:       Tuple =							[np.asarray(lowerCAmelCase__					) for x in speech_inputs]

										return speech_inputs






							def 				_A						(		self      :List[Any]							,				lowerCAmelCase__      :Optional[int]=False							,				lowerCAmelCase__      :Optional[Any]=False					)					->	str:


										'''simple docstring'''




										if equal_length:
													snake_case_					:       Optional[Any] =							[floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
										else:
													# make sure that inputs increase in size
													snake_case_					:       int =							[
													    floats_list((x, self.num_mel_bins)					)
													    for x in range(self.min_seq_length							,				self.max_seq_length							,				self.seq_length_diff					)
													]

										if numpify:
													snake_case_					:       List[Any] =							[np.asarray(lowerCAmelCase__					) for x in speech_inputs]

										return speech_inputs







@require_torch
class  A_						(a_    ,       unittest.TestCase				):
							"""simple docstring"""




							a__ 		=						SpeechTaFeatureExtractor

							def 				_A						(		self      :Union[str, Any]					)					->	int:


										'''simple docstring'''




										snake_case_					:       Tuple =							SpeechTaFeatureExtractionTester(self					)

							def 				_A						(		self      :Tuple							,				lowerCAmelCase__      :Dict					)					->	List[str]:


										'''simple docstring'''




										self.assertTrue(np.all(np.mean(lowerCAmelCase__							,				axis=0					) < 1E-3					)					)
										self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase__							,				axis=0					) - 1					) < 1E-3					)					)

							def 				_A						(		self      :Optional[int]					)					->	int:


										'''simple docstring'''




										snake_case_					:       Union[str, Any] =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										# create three inputs of length 800, 1000, and 1200
										snake_case_					:       Any =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]
										snake_case_					:       Optional[Any] =							[np.asarray(lowerCAmelCase__					) for speech_input in speech_inputs]

										# Test not batched input
										snake_case_					:       Optional[Any] =							feat_extract(speech_inputs[0]							,				return_tensors="np"					).input_values
										snake_case_					:       Optional[int] =							feat_extract(np_speech_inputs[0]							,				return_tensors="np"					).input_values
										self.assertTrue(np.allclose(lowerCAmelCase__							,				lowerCAmelCase__							,				atol=1E-3					)					)

										# Test batched
										snake_case_					:       Optional[int] =							feat_extract(lowerCAmelCase__							,				return_tensors="np"					).input_values
										snake_case_					:       Optional[int] =							feat_extract(lowerCAmelCase__							,				return_tensors="np"					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__							,				lowerCAmelCase__					):
													self.assertTrue(np.allclose(lowerCAmelCase__							,				lowerCAmelCase__							,				atol=1E-3					)					)

							def 				_A						(		self      :List[str]					)					->	str:


										'''simple docstring'''




										snake_case_					:       List[Any] =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										snake_case_					:       List[Any] =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]

										snake_case_					:       List[str] =							["longest", "max_length", "do_not_pad"]
										snake_case_					:       int =							[None, 1_600, None]
										for max_length, padding in zip(lowerCAmelCase__							,				lowerCAmelCase__					):
													snake_case_					:       int =							feat_extract(lowerCAmelCase__							,				padding=lowerCAmelCase__							,				max_length=lowerCAmelCase__							,				return_tensors="np"					)
													snake_case_					:       str =							processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]					)
													self.assertTrue(input_values[0][800:].sum() < 1E-6					)
													self._check_zero_mean_unit_variance(input_values[1][:1_000]					)
													self.assertTrue(input_values[0][1_000:].sum() < 1E-6					)
													self._check_zero_mean_unit_variance(input_values[2][:1_200]					)

							def 				_A						(		self      :Union[str, Any]					)					->	int:


										'''simple docstring'''




										snake_case_					:       int =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										snake_case_					:       Union[str, Any] =							range(800							,				1_400							,				200					)
										snake_case_					:       Dict =							[floats_list((1, x)					)[0] for x in lengths]

										snake_case_					:       int =							["longest", "max_length", "do_not_pad"]
										snake_case_					:       int =							[None, 1_600, None]

										for max_length, padding in zip(lowerCAmelCase__							,				lowerCAmelCase__					):
													snake_case_					:       str =							feat_extract(lowerCAmelCase__							,				max_length=lowerCAmelCase__							,				padding=lowerCAmelCase__					)
													snake_case_					:       Dict =							processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]					)
													self._check_zero_mean_unit_variance(input_values[1][:1_000]					)
													self._check_zero_mean_unit_variance(input_values[2][:1_200]					)

							def 				_A						(		self      :Optional[Any]					)					->	Any:


										'''simple docstring'''




										snake_case_					:       str =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										snake_case_					:       List[Any] =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]
										snake_case_					:       List[str] =							feat_extract(
										    lowerCAmelCase__							,				truncation=lowerCAmelCase__							,				max_length=1_000							,				padding="max_length"							,				return_tensors="np"					)
										snake_case_					:       Optional[int] =							processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1]					)
										self._check_zero_mean_unit_variance(input_values[2]					)

							def 				_A						(		self      :Optional[Any]					)					->	str:


										'''simple docstring'''




										snake_case_					:       Union[str, Any] =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										snake_case_					:       List[str] =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]
										snake_case_					:       str =							feat_extract(
										    lowerCAmelCase__							,				truncation=lowerCAmelCase__							,				max_length=1_000							,				padding="longest"							,				return_tensors="np"					)
										snake_case_					:       Union[str, Any] =							processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1, :1_000]					)
										self._check_zero_mean_unit_variance(input_values[2]					)

										# make sure that if max_length < longest -> then pad to max_length
										self.assertTrue(input_values.shape == (3, 1_000)					)

										snake_case_					:       Union[str, Any] =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]
										snake_case_					:       Optional[int] =							feat_extract(
										    lowerCAmelCase__							,				truncation=lowerCAmelCase__							,				max_length=2_000							,				padding="longest"							,				return_tensors="np"					)
										snake_case_					:       Dict =							processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1, :1_000]					)
										self._check_zero_mean_unit_variance(input_values[2]					)

										# make sure that if max_length > longest -> then pad to longest
										self.assertTrue(input_values.shape == (3, 1_200)					)

							def 				_A						(		self      :Optional[Any]					)					->	Optional[int]:


										'''simple docstring'''




										snake_case_					:       str =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										snake_case_					:       Optional[int] =							np.random.rand(100					).astype(np.floataa					)
										snake_case_					:       int =							np_speech_inputs.tolist()

										for inputs in [py_speech_inputs, np_speech_inputs]:
													snake_case_					:       Dict =							feature_extractor.pad([{"input_values": inputs}]							,				return_tensors="np"					)
													self.assertTrue(np_processed.input_values.dtype == np.floataa					)
													snake_case_					:       int =							feature_extractor.pad([{"input_values": inputs}]							,				return_tensors="pt"					)
													self.assertTrue(pt_processed.input_values.dtype == torch.floataa					)

							def 				_A						(		self      :Union[str, Any]					)					->	int:


										'''simple docstring'''




										snake_case_					:       str =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										# create three inputs of length 800, 1000, and 1200
										snake_case_					:       Dict =							[floats_list((1, x)					)[0] for x in range(800							,				1_400							,				200					)]
										snake_case_					:       str =							[np.asarray(lowerCAmelCase__					) for speech_input in speech_inputs]

										# Test feature size
										snake_case_					:       List[str] =							feature_extractor(audio_target=lowerCAmelCase__							,				padding=lowerCAmelCase__							,				return_tensors="np"					).input_values
										self.assertTrue(input_values.ndim == 3					)
										self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

										# Test not batched input
										snake_case_					:       Any =							feature_extractor(speech_inputs[0]							,				return_tensors="np"					).input_values
										snake_case_					:       Optional[Any] =							feature_extractor(np_speech_inputs[0]							,				return_tensors="np"					).input_values
										self.assertTrue(np.allclose(lowerCAmelCase__							,				lowerCAmelCase__							,				atol=1E-3					)					)

										# Test batched
										snake_case_					:       int =							feature_extractor(lowerCAmelCase__							,				return_tensors="np"					).input_values
										snake_case_					:       List[str] =							feature_extractor(lowerCAmelCase__							,				return_tensors="np"					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__							,				lowerCAmelCase__					):
													self.assertTrue(np.allclose(lowerCAmelCase__							,				lowerCAmelCase__							,				atol=1E-3					)					)

										# Test 2-D numpy arrays are batched.
										snake_case_					:       Optional[Any] =							[floats_list((1, x)					)[0] for x in (800, 800, 800)]
										snake_case_					:       Union[str, Any] =							np.asarray(lowerCAmelCase__					)
										snake_case_					:       Optional[int] =							feature_extractor(lowerCAmelCase__							,				return_tensors="np"					).input_values
										snake_case_					:       Tuple =							feature_extractor(lowerCAmelCase__							,				return_tensors="np"					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__							,				lowerCAmelCase__					):
													self.assertTrue(np.allclose(lowerCAmelCase__							,				lowerCAmelCase__							,				atol=1E-3					)					)

							def 				_A						(		self      :Optional[Any]					)					->	List[Any]:


										'''simple docstring'''




										snake_case_					:       str =							self.feat_extract_tester.prepare_inputs_for_target()
										snake_case_					:       Optional[int] =							self.feature_extraction_class(**self.feat_extract_dict					)
										snake_case_					:       List[Any] =							feat_extract.model_input_names[0]

										snake_case_					:       int =							BatchFeature({input_name: speech_inputs}					)

										self.assertTrue(all(len(lowerCAmelCase__					) == len(lowerCAmelCase__					) for x, y in zip(lowerCAmelCase__							,				processed_features[input_name]					)					)					)

										snake_case_					:       str =							self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase__					)
										snake_case_					:       str =							BatchFeature({input_name: speech_inputs}							,				tensor_type="np"					)

										snake_case_					:       List[str] =							processed_features[input_name]

										if len(batch_features_input.shape					) < 3:
													snake_case_					:       str =							batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)

							@require_torch
							def 				_A						(		self      :Optional[Any]					)					->	str:


										'''simple docstring'''




										snake_case_					:       Optional[int] =							self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase__					)
										snake_case_					:       List[Any] =							self.feature_extraction_class(**self.feat_extract_dict					)
										snake_case_					:       List[str] =							feat_extract.model_input_names[0]

										snake_case_					:       List[Any] =							BatchFeature({input_name: speech_inputs}							,				tensor_type="pt"					)

										snake_case_					:       Tuple =							processed_features[input_name]

										if len(batch_features_input.shape					) < 3:
													snake_case_					:       Any =							batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)

							@require_torch
							def 				_A						(		self      :Optional[Any]					)					->	Tuple:


										'''simple docstring'''




										snake_case_					:       Optional[Any] =							self.feature_extraction_class(**self.feat_extract_dict					)
										snake_case_					:       Union[str, Any] =							self.feat_extract_tester.prepare_inputs_for_target()
										snake_case_					:       Any =							feat_extract.model_input_names[0]

										snake_case_					:       Dict =							BatchFeature({input_name: speech_inputs}					)

										snake_case_					:       Union[str, Any] =							feat_extract.num_mel_bins  # hack!

										snake_case_					:       Dict =							feat_extract.pad(lowerCAmelCase__							,				padding="longest"							,				return_tensors="np"					)[input_name]
										snake_case_					:       Any =							feat_extract.pad(lowerCAmelCase__							,				padding="longest"							,				return_tensors="pt"					)[input_name]

										self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1E-2					)

							def 				_A						(		self      :Dict					)					->	Tuple:


										'''simple docstring'''




										snake_case_					:       Optional[int] =							self.feat_extract_dict
										snake_case_					:       Optional[int] =							True
										snake_case_					:       Optional[Any] =							self.feature_extraction_class(**lowerCAmelCase__					)
										snake_case_					:       List[Any] =							self.feat_extract_tester.prepare_inputs_for_target()
										snake_case_					:       Optional[int] =							[len(lowerCAmelCase__					) for x in speech_inputs]
										snake_case_					:       int =							feat_extract.model_input_names[0]

										snake_case_					:       str =							BatchFeature({input_name: speech_inputs}					)

										snake_case_					:       List[Any] =							feat_extract.num_mel_bins  # hack!

										snake_case_					:       Optional[Any] =							feat_extract.pad(lowerCAmelCase__							,				padding="longest"							,				return_tensors="np"					)
										self.assertIn("attention_mask"							,				lowerCAmelCase__					)
										self.assertListEqual(list(processed.attention_mask.shape					)							,				list(processed[input_name].shape[:2]					)					)
										self.assertListEqual(processed.attention_mask.sum(-1					).tolist()							,				lowerCAmelCase__					)

							def 				_A						(		self      :Dict					)					->	int:


										'''simple docstring'''




										snake_case_					:       List[str] =							self.feat_extract_dict
										snake_case_					:       Any =							True
										snake_case_					:       Optional[Any] =							self.feature_extraction_class(**lowerCAmelCase__					)
										snake_case_					:       int =							self.feat_extract_tester.prepare_inputs_for_target()
										snake_case_					:       List[Any] =							[len(lowerCAmelCase__					) for x in speech_inputs]
										snake_case_					:       str =							feat_extract.model_input_names[0]

										snake_case_					:       List[str] =							BatchFeature({input_name: speech_inputs}					)
										snake_case_					:       Any =							min(lowerCAmelCase__					)

										snake_case_					:       Dict =							feat_extract.num_mel_bins  # hack!

										snake_case_					:       Union[str, Any] =							feat_extract.pad(
										    lowerCAmelCase__							,				padding="max_length"							,				max_length=lowerCAmelCase__							,				truncation=lowerCAmelCase__							,				return_tensors="np"					)
										self.assertIn("attention_mask"							,				lowerCAmelCase__					)
										self.assertListEqual(
										    list(processed_pad.attention_mask.shape					)							,				[processed_pad[input_name].shape[0], max_length]					)
										self.assertListEqual(
										    processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()							,				[max_length for x in speech_inputs]					)

							def 				_A						(		self      :str							,				lowerCAmelCase__      :Tuple					)					->	Tuple:


										'''simple docstring'''




										from datasets import load_dataset

										snake_case_					:       int =							load_dataset("hf-internal-testing/librispeech_asr_dummy"							,				"clean"							,				split="validation"					)
										# automatic decoding with librispeech
										snake_case_					:       str =							ds.sort("id"					).select(range(lowerCAmelCase__					)					)[:num_samples]["audio"]

										return [x["array"] for x in speech_samples]

							def 				_A						(		self      :Optional[int]					)					->	Optional[int]:


										'''simple docstring'''




										snake_case_					:       Optional[Any] =							torch.tensor(
										    [2.3_8_0_4E-0_3, 2.0_7_5_2E-0_3, 1.9_8_3_6E-0_3, 2.1_0_5_7E-0_3, 1.6_1_7_4E-0_3,
										     3.0_5_1_8E-0_4, 9.1_5_5_3E-0_5, 3.3_5_6_9E-0_4, 9.7_6_5_6E-0_4, 1.8_3_1_1E-0_3,
										     2.0_1_4_2E-0_3, 2.1_0_5_7E-0_3, 1.7_3_9_5E-0_3, 4.5_7_7_6E-0_4, -3.9_6_7_3E-0_4,
										     4.5_7_7_6E-0_4, 1.0_0_7_1E-0_3, 9.1_5_5_3E-0_5, 4.8_8_2_8E-0_4, 1.1_5_9_7E-0_3,
										     7.3_2_4_2E-0_4, 9.4_6_0_4E-0_4, 1.8_0_0_5E-0_3, 1.8_3_1_1E-0_3, 8.8_5_0_1E-0_4,
										     4.2_7_2_5E-0_4, 4.8_8_2_8E-0_4, 7.3_2_4_2E-0_4, 1.0_9_8_6E-0_3, 2.1_0_5_7E-0_3]					)
										# fmt: on

										snake_case_					:       Any =							self._load_datasamples(1					)
										snake_case_					:       str =							SpeechTaFeatureExtractor()
										snake_case_					:       Union[str, Any] =							feature_extractor(lowerCAmelCase__							,				return_tensors="pt"					).input_values
										self.assertEquals(input_values.shape							,				(1, 93_680)					)
										self.assertTrue(torch.allclose(input_values[0, :30]							,				lowerCAmelCase__							,				atol=1E-6					)					)






							def 				_A						(		self      :List[str]					)					->	str:


										'''simple docstring'''




										snake_case_					:       List[str] =							torch.tensor(
										    [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
										     -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
										     -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
										     -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8]					)
										# fmt: on

										snake_case_					:       List[Any] =							self._load_datasamples(1					)
										snake_case_					:       int =							SpeechTaFeatureExtractor()
										snake_case_					:       Optional[Any] =							feature_extractor(audio_target=lowerCAmelCase__							,				return_tensors="pt"					).input_values
										self.assertEquals(input_values.shape							,				(1, 366, 80)					)
										self.assertTrue(torch.allclose(input_values[0, 0, :30]							,				lowerCAmelCase__							,				atol=1E-4					)					)










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCamelCase   :			Optional[int]          = {
    "configuration_jukebox": [
        "JUKEBOX_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "JukeboxConfig",
        "JukeboxPriorConfig",
        "JukeboxVQVAEConfig",
    ],
    "tokenization_jukebox": ["JukeboxTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCamelCase   :			int          = [
		    "JUKEBOX_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "JukeboxModel",
		    "JukeboxPreTrainedModel",
		    "JukeboxVQVAE",
		    "JukeboxPrior",
		]

if TYPE_CHECKING:
		from .configuration_jukebox import (
		    JUKEBOX_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    JukeboxConfig,
		    JukeboxPriorConfig,
		    JukeboxVQVAEConfig,
		)
		from .tokenization_jukebox import JukeboxTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_jukebox import (
				    JUKEBOX_PRETRAINED_MODEL_ARCHIVE_LIST,
				    JukeboxModel,
				    JukeboxPreTrainedModel,
				    JukeboxPrior,
				    JukeboxVQVAE,
				)

else:
		import sys

		__UpperCamelCase   :			List[str]          = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

