






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


SCREAMING_SNAKE_CASE__							=		random.Random()

def      __lowercase					( snake_case,  snake_case=1.0,  snake_case=None,  snake_case=None ):







				"""simple docstring"""






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

				__magic_name__		:str        =      []
				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 						lowerCamelCase_				(      unittest.TestCase ):







				def __init__(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase=7       ,					__lowerCAmelCase=4_0_0       ,					__lowerCAmelCase=2_0_0_0       ,					__lowerCAmelCase=1       ,					__lowerCAmelCase=0.0       ,					__lowerCAmelCase=1_6_0_0_0       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=8_0       ,					__lowerCAmelCase=1_6       ,					__lowerCAmelCase=6_4       ,					__lowerCAmelCase="hann_window"       ,					__lowerCAmelCase=8_0       ,					__lowerCAmelCase=7_6_0_0       ,					__lowerCAmelCase=1E-10       ,					__lowerCAmelCase=True       ,					):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      parent
								__magic_name__		:int        =      batch_size
								__magic_name__		:str        =      min_seq_length
								__magic_name__		:List[str]        =      max_seq_length
								__magic_name__		:Optional[Any]        =      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
								__magic_name__		:Dict        =      feature_size
								__magic_name__		:List[str]        =      padding_value
								__magic_name__		:List[str]        =      sampling_rate
								__magic_name__		:Dict        =      do_normalize
								__magic_name__		:Union[str, Any]        =      num_mel_bins
								__magic_name__		:Optional[int]        =      hop_length
								__magic_name__		:Union[str, Any]        =      win_length
								__magic_name__		:Tuple        =      win_function
								__magic_name__		:Optional[Any]        =      fmin
								__magic_name__		:Union[str, Any]        =      fmax
								__magic_name__		:str        =      mel_floor
								__magic_name__		:Tuple        =      return_attention_mask







				def 			A	(						self     ):
								"""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       ,					__lowerCAmelCase=False       ,					__lowerCAmelCase=False     ):
								"""simple docstring"""
								def _flatten(__lowerCAmelCase     ):
												return list(itertools.chain(*__lowerCAmelCase     )     )

								if equal_length:
												__magic_name__		:Optional[int]        =      floats_list((self.batch_size, self.max_seq_length)     )
								else:
												# make sure that inputs increase in size
												__magic_name__		:Dict        =      [
												    _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:
												__magic_name__		:List[str]        =      [np.asarray(__lowerCAmelCase     ) for x in speech_inputs]

								return speech_inputs







				def 			A	(						self       ,					__lowerCAmelCase=False       ,					__lowerCAmelCase=False     ):
								"""simple docstring"""
								if equal_length:
												__magic_name__		:List[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
												__magic_name__		:Optional[Any]        =      [
												    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:
												__magic_name__		:int        =      [np.asarray(__lowerCAmelCase     ) for x in speech_inputs]

								return speech_inputs







@require_torch
class 						lowerCamelCase_				(      UpperCamelCase__			,				unittest.TestCase ):
				a__					       =  SpeechTaFeatureExtractor







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      SpeechTaFeatureExtractionTester(self     )







				def 			A	(						self       ,					__lowerCAmelCase     ):
								"""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     ):
								"""simple docstring"""
								# Tests that all call wrap to encode_plus and batch_encode_plus
								__magic_name__		:Union[str, Any]        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								# create three inputs of length 800, 1000, and 1200
								__magic_name__		:Any        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]
								__magic_name__		:str        =      [np.asarray(__lowerCAmelCase     ) for speech_input in speech_inputs]

								# Test not batched input
								__magic_name__		:str        =      feat_extract(speech_inputs[0]       ,					return_tensors='''np'''     ).input_values
								__magic_name__		:int        =      feat_extract(np_speech_inputs[0]       ,					return_tensors='''np'''     ).input_values
								self.assertTrue(np.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-3     )     )

								# Test batched
								__magic_name__		:Optional[int]        =      feat_extract(__lowerCAmelCase       ,					return_tensors='''np'''     ).input_values
								__magic_name__		:List[str]        =      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     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								__magic_name__		:Dict        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]

								__magic_name__		:Any        =      ['''longest''', '''max_length''', '''do_not_pad''']
								__magic_name__		:Optional[Any]        =      [None, 1_6_0_0, None]
								for max_length, padding in zip(__lowerCAmelCase       ,					__lowerCAmelCase     ):
												__magic_name__		:Optional[int]        =      feat_extract(__lowerCAmelCase       ,					padding=__lowerCAmelCase       ,					max_length=__lowerCAmelCase       ,					return_tensors='''np'''     )
												__magic_name__		:Union[str, Any]        =      processed.input_values

												self._check_zero_mean_unit_variance(input_values[0][:8_0_0]     )
												self.assertTrue(input_values[0][8_0_0:].sum() < 1E-6     )
												self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]     )
												self.assertTrue(input_values[0][1_0_0_0:].sum() < 1E-6     )
												self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								__magic_name__		:int        =      range(8_0_0       ,					1_4_0_0       ,					2_0_0     )
								__magic_name__		:str        =      [floats_list((1, x)     )[0] for x in lengths]

								__magic_name__		:Any        =      ['''longest''', '''max_length''', '''do_not_pad''']
								__magic_name__		:List[str]        =      [None, 1_6_0_0, None]

								for max_length, padding in zip(__lowerCAmelCase       ,					__lowerCAmelCase     ):
												__magic_name__		:Optional[int]        =      feat_extract(__lowerCAmelCase       ,					max_length=__lowerCAmelCase       ,					padding=__lowerCAmelCase     )
												__magic_name__		:Dict        =      processed.input_values

												self._check_zero_mean_unit_variance(input_values[0][:8_0_0]     )
												self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]     )
												self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								__magic_name__		:int        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]
								__magic_name__		:Optional[int]        =      feat_extract(
								    __lowerCAmelCase       ,					truncation=__lowerCAmelCase       ,					max_length=1_0_0_0       ,					padding='''max_length'''       ,					return_tensors='''np'''     )
								__magic_name__		:Union[str, Any]        =      processed.input_values

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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								__magic_name__		:List[Any]        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]
								__magic_name__		:Dict        =      feat_extract(
								    __lowerCAmelCase       ,					truncation=__lowerCAmelCase       ,					max_length=1_0_0_0       ,					padding='''longest'''       ,					return_tensors='''np'''     )
								__magic_name__		:Optional[Any]        =      processed.input_values

								self._check_zero_mean_unit_variance(input_values[0, :8_0_0]     )
								self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]     )
								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_0_0_0)     )

								__magic_name__		:List[Any]        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]
								__magic_name__		:List[str]        =      feat_extract(
								    __lowerCAmelCase       ,					truncation=__lowerCAmelCase       ,					max_length=2_0_0_0       ,					padding='''longest'''       ,					return_tensors='''np'''     )
								__magic_name__		:Any        =      processed.input_values

								self._check_zero_mean_unit_variance(input_values[0, :8_0_0]     )
								self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]     )
								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_2_0_0)     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								__magic_name__		:Tuple        =      np.random.rand(1_0_0     ).astype(np.floataa     )
								__magic_name__		:Optional[int]        =      np_speech_inputs.tolist()

								for inputs in [py_speech_inputs, np_speech_inputs]:
												__magic_name__		:List[Any]        =      feature_extractor.pad([{'''input_values''': inputs}]       ,					return_tensors='''np'''     )
												self.assertTrue(np_processed.input_values.dtype == np.floataa     )
												__magic_name__		:Union[str, Any]        =      feature_extractor.pad([{'''input_values''': inputs}]       ,					return_tensors='''pt'''     )
												self.assertTrue(pt_processed.input_values.dtype == torch.floataa     )







				def 			A	(						self     ):
								"""simple docstring"""
								# Tests that all call wrap to encode_plus and batch_encode_plus
								__magic_name__		:Optional[Any]        =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
								# create three inputs of length 800, 1000, and 1200
								__magic_name__		:Union[str, Any]        =      [floats_list((1, x)     )[0] for x in range(8_0_0       ,					1_4_0_0       ,					2_0_0     )]
								__magic_name__		:List[Any]        =      [np.asarray(__lowerCAmelCase     ) for speech_input in speech_inputs]

								# Test feature size
								__magic_name__		:List[Any]        =      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
								__magic_name__		:str        =      feature_extractor(speech_inputs[0]       ,					return_tensors='''np'''     ).input_values
								__magic_name__		:Optional[int]        =      feature_extractor(np_speech_inputs[0]       ,					return_tensors='''np'''     ).input_values
								self.assertTrue(np.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-3     )     )

								# Test batched
								__magic_name__		:Optional[Any]        =      feature_extractor(__lowerCAmelCase       ,					return_tensors='''np'''     ).input_values
								__magic_name__		:Union[str, Any]        =      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.
								__magic_name__		:str        =      [floats_list((1, x)     )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
								__magic_name__		:Optional[Any]        =      np.asarray(__lowerCAmelCase     )
								__magic_name__		:List[str]        =      feature_extractor(__lowerCAmelCase       ,					return_tensors='''np'''     ).input_values
								__magic_name__		: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     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      self.feat_extract_tester.prepare_inputs_for_target()
								__magic_name__		:int        =      self.feature_extraction_class(**self.feat_extract_dict     )
								__magic_name__		:List[str]        =      feat_extract.model_input_names[0]

								__magic_name__		:Optional[int]        =      BatchFeature({input_name: speech_inputs}     )

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

								__magic_name__		:Optional[int]        =      self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCAmelCase     )
								__magic_name__		:Tuple        =      BatchFeature({input_name: speech_inputs}       ,					tensor_type='''np'''     )

								__magic_name__		:Optional[Any]        =      processed_features[input_name]

								if len(batch_features_input.shape     ) < 3:
												__magic_name__		:Union[str, 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     ):
								"""simple docstring"""
								__magic_name__		:int        =      self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCAmelCase     )
								__magic_name__		:Optional[Any]        =      self.feature_extraction_class(**self.feat_extract_dict     )
								__magic_name__		:List[str]        =      feat_extract.model_input_names[0]

								__magic_name__		:int        =      BatchFeature({input_name: speech_inputs}       ,					tensor_type='''pt'''     )

								__magic_name__		:Optional[Any]        =      processed_features[input_name]

								if len(batch_features_input.shape     ) < 3:
												__magic_name__		: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     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      self.feature_extraction_class(**self.feat_extract_dict     )
								__magic_name__		:Optional[int]        =      self.feat_extract_tester.prepare_inputs_for_target()
								__magic_name__		:Union[str, Any]        =      feat_extract.model_input_names[0]

								__magic_name__		:List[Any]        =      BatchFeature({input_name: speech_inputs}     )

								__magic_name__		:Dict        =      feat_extract.num_mel_bins  # hack!

								__magic_name__		:Any        =      feat_extract.pad(__lowerCAmelCase       ,					padding='''longest'''       ,					return_tensors='''np'''     )[input_name]
								__magic_name__		:str        =      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     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      self.feat_extract_dict
								__magic_name__		:List[Any]        =      True
								__magic_name__		:int        =      self.feature_extraction_class(**__lowerCAmelCase     )
								__magic_name__		:Optional[Any]        =      self.feat_extract_tester.prepare_inputs_for_target()
								__magic_name__		:List[str]        =      [len(__lowerCAmelCase     ) for x in speech_inputs]
								__magic_name__		:str        =      feat_extract.model_input_names[0]

								__magic_name__		:Optional[int]        =      BatchFeature({input_name: speech_inputs}     )

								__magic_name__		:str        =      feat_extract.num_mel_bins  # hack!

								__magic_name__		:List[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     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      self.feat_extract_dict
								__magic_name__		:Optional[Any]        =      True
								__magic_name__		:Dict        =      self.feature_extraction_class(**__lowerCAmelCase     )
								__magic_name__		:int        =      self.feat_extract_tester.prepare_inputs_for_target()
								__magic_name__		:Optional[int]        =      [len(__lowerCAmelCase     ) for x in speech_inputs]
								__magic_name__		:Optional[Any]        =      feat_extract.model_input_names[0]

								__magic_name__		:Optional[int]        =      BatchFeature({input_name: speech_inputs}     )
								__magic_name__		:str        =      min(__lowerCAmelCase     )

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

								__magic_name__		:Tuple        =      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       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								from datasets import load_dataset

								__magic_name__		:List[Any]        =      load_dataset('''hf-internal-testing/librispeech_asr_dummy'''       ,					'''clean'''       ,					split='''validation'''     )
								# automatic decoding with librispeech
								__magic_name__		:List[Any]        =      ds.sort('''id'''     ).select(range(__lowerCAmelCase     )     )[:num_samples]['''audio''']

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







				def 			A	(						self     ):
								"""simple docstring"""
								# fmt: off
								__magic_name__		:Tuple        =      torch.tensor(
								    [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
								     3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
								     2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
								     4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
								     7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
								     4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]     )
								# fmt: on

								__magic_name__		:List[Any]        =      self._load_datasamples(1     )
								__magic_name__		:Any        =      SpeechTaFeatureExtractor()
								__magic_name__		:List[str]        =      feature_extractor(__lowerCAmelCase       ,					return_tensors='''pt'''     ).input_values
								self.assertEquals(input_values.shape       ,					(1, 9_3_6_8_0)     )
								self.assertTrue(torch.allclose(input_values[0, :3_0]       ,					__lowerCAmelCase       ,					atol=1E-6     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								# fmt: off
								__magic_name__		:List[str]        =      torch.tensor(
								    [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
								     -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
								     -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
								     -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]     )
								# fmt: on

								__magic_name__		:Union[str, Any]        =      self._load_datasamples(1     )
								__magic_name__		:Optional[int]        =      SpeechTaFeatureExtractor()
								__magic_name__		:Optional[int]        =      feature_extractor(audio_target=__lowerCAmelCase       ,					return_tensors='''pt'''     ).input_values
								self.assertEquals(input_values.shape       ,					(1, 3_6_6, 8_0)     )
								self.assertTrue(torch.allclose(input_values[0, 0, :3_0]       ,					__lowerCAmelCase       ,					atol=1E-4     )     )














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE__      :			Tuple							=		{
    """configuration_table_transformer""": [
        """TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """TableTransformerConfig""",
        """TableTransformerOnnxConfig""",
    ]
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__      :			List[str]							=		[
					    """TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TableTransformerForObjectDetection""",
					    """TableTransformerModel""",
					    """TableTransformerPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_table_transformer import (
					    TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    TableTransformerConfig,
					    TableTransformerOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_table_transformer import (
										    TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TableTransformerForObjectDetection,
										    TableTransformerModel,
										    TableTransformerPreTrainedModel,
										)

else:
					import sys

					SCREAMING_SNAKE_CASE__      :			Union[str, Any]							=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






