





import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
     from huggingface_hub import snapshot_download
     from pyctcdecode import BeamSearchDecoderCTC

     from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
     from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
     from transformers import WavaVecaForCTC



@require_pyctcdecode
class 							_UpperCAmelCase       (       unittest.TestCase       ):

  """simple docstring"""


  def 							lowercase						(							self					:						str	)				->		Tuple:
     __lowerCAmelCase				      =      '| <pad> <unk> <s> </s> a b c d e f g h i j k'.split()
     __lowerCAmelCase				      =      dict(zip(lowercase__   ,    range(len(lowercase__	)	)	)	)

     __lowerCAmelCase				      =      {
         'unk_token': '<unk>',
         'bos_token': '<s>',
         'eos_token': '</s>',
     }
     __lowerCAmelCase				      =      {
         'feature_size': 1,
         'padding_value': 0.0,
         'sampling_rate': 1_6_0_0_0,
         'return_attention_mask': False,
         'do_normalize': True,
     }

     __lowerCAmelCase				      =      tempfile.mkdtemp()
     __lowerCAmelCase				      =      os.path.join(self.tmpdirname   ,    VOCAB_FILES_NAMES['vocab_file']	)
     __lowerCAmelCase				      =      os.path.join(self.tmpdirname   ,    lowercase__	)
     with open(self.vocab_file   ,    'w'   ,    encoding='utf-8'	) as fp:
        fp.write(json.dumps(lowercase__	) + '\n'	)

     with open(self.feature_extraction_file   ,    'w'   ,    encoding='utf-8'	) as fp:
        fp.write(json.dumps(lowercase__	) + '\n'	)

     # load decoder from hub
     __lowerCAmelCase				      =      'hf-internal-testing/ngram-beam-search-decoder'






  def 							lowercase						(							self					:						Optional[int]   ,    **lowerCAmelCase_					:						Any	)				->		int:
     __lowerCAmelCase				      =      self.add_kwargs_tokens_map.copy()
     kwargs.update(lowercase__	)
     return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname   ,    **lowercase__	)






  def 							lowercase						(							self					:						Optional[int]   ,    **lowerCAmelCase_					:						str	)				->		Optional[int]:
     return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname   ,    **lowercase__	)






  def 							lowercase						(							self					:						Any   ,    **lowerCAmelCase_					:						Optional[int]	)				->		Optional[Any]:
     return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name   ,    **lowercase__	)






  def 							lowercase						(							self					:						Optional[Any]	)				->		Any:
     shutil.rmtree(self.tmpdirname	)






  def 							lowercase						(							self					:						Union[str, Any]	)				->		Tuple:
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     processor.save_pretrained(self.tmpdirname	)
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname	)

     # tokenizer
     self.assertEqual(processor.tokenizer.get_vocab()   ,    tokenizer.get_vocab()	)
     self.assertIsInstance(processor.tokenizer   ,    lowercase__	)

     # feature extractor
     self.assertEqual(processor.feature_extractor.to_json_string()   ,    feature_extractor.to_json_string()	)
     self.assertIsInstance(processor.feature_extractor   ,    lowercase__	)

     # decoder
     self.assertEqual(processor.decoder._alphabet.labels   ,    decoder._alphabet.labels	)
     self.assertEqual(
         processor.decoder.model_container[decoder._model_key]._unigram_set   ,    decoder.model_container[decoder._model_key]._unigram_set   ,    )
     self.assertIsInstance(processor.decoder   ,    lowercase__	)






  def 							lowercase						(							self					:						Dict	)				->		int:
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(
         tokenizer=self.get_tokenizer()   ,    feature_extractor=self.get_feature_extractor()   ,    decoder=self.get_decoder()	)
     processor.save_pretrained(self.tmpdirname	)

     # make sure that error is thrown when decoder alphabet doesn't match
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained(
         self.tmpdirname   ,    alpha=5.0   ,    beta=3.0   ,    score_boundary=-7.0   ,    unk_score_offset=3	)

     # decoder
     self.assertEqual(processor.language_model.alpha   ,    5.0	)
     self.assertEqual(processor.language_model.beta   ,    3.0	)
     self.assertEqual(processor.language_model.score_boundary   ,    -7.0	)
     self.assertEqual(processor.language_model.unk_score_offset   ,    3	)






  def 							lowercase						(							self					:						Tuple	)				->		Optional[int]:
     __lowerCAmelCase				      =      self.get_tokenizer()
     # add token to trigger raise
     tokenizer.add_tokens(['xx']	)
     with self.assertRaisesRegex(lowercase__   ,    'include'	):
        WavaVecaProcessorWithLM(
            tokenizer=lowercase__   ,    feature_extractor=self.get_feature_extractor()   ,    decoder=self.get_decoder()	)






  def 							lowercase						(							self					:						List[str]	)				->		str:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      floats_list((3, 1_0_0_0)	)

     __lowerCAmelCase				      =      feature_extractor(lowercase__   ,    return_tensors='np'	)
     __lowerCAmelCase				      =      processor(lowercase__   ,    return_tensors='np'	)

     for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum()   ,    input_processor[key].sum()   ,    delta=1e-2	)






  def 							lowercase						(							self					:						int	)				->		Any:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      'This is a test string'

     __lowerCAmelCase				      =      processor(text=lowercase__	)

     __lowerCAmelCase				      =      tokenizer(lowercase__	)

     for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]   ,    encoded_processor[key]	)






  def 							lowercase						(							self					:						Any   ,    lowerCAmelCase_					:						Union[str, Any]=(2, 1_0, 1_6)   ,    lowerCAmelCase_					:						Optional[Any]=7_7	)				->		Optional[int]:
     np.random.seed(lowercase__	)
     return np.random.rand(*lowercase__	)






  def 							lowercase						(							self					:						str	)				->		Any:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      self._get_dummy_logits(shape=(1_0, 1_6)   ,    seed=1_3	)

     __lowerCAmelCase				      =      processor.decode(lowercase__	)

     __lowerCAmelCase				      =      decoder.decode_beams(lowercase__	)[0]

     self.assertEqual(decoded_decoder[0]   ,    decoded_processor.text	)
     self.assertEqual('</s> <s> </s>'   ,    decoded_processor.text	)
     self.assertEqual(decoded_decoder[-2]   ,    decoded_processor.logit_score	)
     self.assertEqual(decoded_decoder[-1]   ,    decoded_processor.lm_score	)






  @parameterized.expand([[None], ['fork'], ['spawn']]	)
  def 							lowercase						(							self					:						int   ,    lowerCAmelCase_					:						Optional[int]	)				->		Dict:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      self._get_dummy_logits()

     # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
     #       otherwise, the LM won't be available to the pool's sub-processes.
     # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
     if pool_context is None:
        __lowerCAmelCase				      =      processor.batch_decode(lowercase__	)
     else:
        with get_context(lowercase__	).Pool() as pool:
           __lowerCAmelCase				      =      processor.batch_decode(lowercase__   ,    lowercase__	)

     __lowerCAmelCase				      =      list(lowercase__	)

     with get_context('fork'	).Pool() as p:
        __lowerCAmelCase				      =      decoder.decode_beams_batch(lowercase__   ,    lowercase__	)

     __lowerCAmelCase      ,      __lowerCAmelCase      ,      __lowerCAmelCase				      =      [], [], []
     for beams in decoded_beams:
        texts_decoder.append(beams[0][0]	)
        logit_scores_decoder.append(beams[0][-2]	)
        lm_scores_decoder.append(beams[0][-1]	)

     self.assertListEqual(lowercase__   ,    decoded_processor.text	)
     self.assertListEqual(['<s> <s> </s>', '<s> <s> <s>']   ,    decoded_processor.text	)
     self.assertListEqual(lowercase__   ,    decoded_processor.logit_score	)
     self.assertListEqual(lowercase__   ,    decoded_processor.lm_score	)






  def 							lowercase						(							self					:						Union[str, Any]	)				->		Dict:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      self._get_dummy_logits()

     __lowerCAmelCase				      =      1_5
     __lowerCAmelCase				      =      -2_0.0
     __lowerCAmelCase				      =      -4.0

     __lowerCAmelCase				      =      processor.batch_decode(
         lowercase__   ,    beam_width=lowercase__   ,    beam_prune_logp=lowercase__   ,    token_min_logp=lowercase__   ,    )
     __lowerCAmelCase				      =      decoded_processor_out.text

     __lowerCAmelCase				      =      list(lowercase__	)

     with get_context('fork'	).Pool() as pool:
        __lowerCAmelCase				      =      decoder.decode_beams_batch(
            lowercase__   ,    lowercase__   ,    beam_width=lowercase__   ,    beam_prune_logp=lowercase__   ,    token_min_logp=lowercase__   ,    )

     __lowerCAmelCase				      =      [d[0][0] for d in decoded_decoder_out]
     __lowerCAmelCase				      =      [d[0][2] for d in decoded_decoder_out]
     __lowerCAmelCase				      =      [d[0][3] for d in decoded_decoder_out]

     self.assertListEqual(lowercase__   ,    lowercase__	)
     self.assertListEqual(['</s> <s> <s>', '<s> <s> <s>']   ,    lowercase__	)

     self.assertTrue(np.array_equal(lowercase__   ,    decoded_processor_out.logit_score	)	)
     self.assertTrue(np.allclose([-2_0.0_5_4, -1_8.4_4_7]   ,    lowercase__   ,    atol=1e-3	)	)

     self.assertTrue(np.array_equal(lowercase__   ,    decoded_processor_out.lm_score	)	)
     self.assertTrue(np.allclose([-1_5.5_5_4, -1_3.9_4_7_4]   ,    lowercase__   ,    atol=1e-3	)	)






  def 							lowercase						(							self					:						int	)				->		List[str]:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     __lowerCAmelCase				      =      self._get_dummy_logits()

     __lowerCAmelCase				      =      2.0
     __lowerCAmelCase				      =      5.0
     __lowerCAmelCase				      =      -2_0.0
     __lowerCAmelCase				      =      True

     __lowerCAmelCase				      =      processor.batch_decode(
         lowercase__   ,    alpha=lowercase__   ,    beta=lowercase__   ,    unk_score_offset=lowercase__   ,    lm_score_boundary=lowercase__   ,    )
     __lowerCAmelCase				      =      decoded_processor_out.text

     __lowerCAmelCase				      =      list(lowercase__	)
     decoder.reset_params(
         alpha=lowercase__   ,    beta=lowercase__   ,    unk_score_offset=lowercase__   ,    lm_score_boundary=lowercase__   ,    )

     with get_context('fork'	).Pool() as pool:
        __lowerCAmelCase				      =      decoder.decode_beams_batch(
            lowercase__   ,    lowercase__   ,    )

     __lowerCAmelCase				      =      [d[0][0] for d in decoded_decoder_out]

     self.assertListEqual(lowercase__   ,    lowercase__	)
     self.assertListEqual(['<s> </s> <s> </s> </s>', '</s> </s> <s> </s> </s>']   ,    lowercase__	)
     __lowerCAmelCase				      =      processor.decoder.model_container[processor.decoder._model_key]
     self.assertEqual(lm_model.alpha   ,    2.0	)
     self.assertEqual(lm_model.beta   ,    5.0	)
     self.assertEqual(lm_model.unk_score_offset   ,    -2_0.0	)
     self.assertEqual(lm_model.score_boundary   ,    lowercase__	)






  def 							lowercase						(							self					:						Dict	)				->		Union[str, Any]:
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'	)

     __lowerCAmelCase				      =      processor.decoder.model_container[processor.decoder._model_key]
     __lowerCAmelCase				      =      Path(language_model._kenlm_model.path.decode('utf-8'	)	).parent.parent.absolute()

     __lowerCAmelCase				      =      os.listdir(lowercase__	)
     __lowerCAmelCase				      =      ['alphabet.json', 'language_model']

     downloaded_decoder_files.sort()
     expected_decoder_files.sort()

     # test that only decoder relevant files from
     # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
     # are downloaded and none of the rest (e.g. README.md, ...)
     self.assertListEqual(lowercase__   ,    lowercase__	)






  def 							lowercase						(							self					:						Any	)				->		int:
     __lowerCAmelCase				      =      snapshot_download('hf-internal-testing/processor_with_lm'	)

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained(lowercase__	)

     __lowerCAmelCase				      =      processor.decoder.model_container[processor.decoder._model_key]
     __lowerCAmelCase				      =      Path(language_model._kenlm_model.path.decode('utf-8'	)	).parent.parent.absolute()

     __lowerCAmelCase				      =      os.listdir(lowercase__	)
     __lowerCAmelCase				      =      os.listdir(lowercase__	)

     local_decoder_files.sort()
     expected_decoder_files.sort()

     # test that both decoder form hub and local files in cache are the same
     self.assertListEqual(lowercase__   ,    lowercase__	)






  def 							lowercase						(							self					:						Optional[Any]	)				->		List[str]:
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'	)
     __lowerCAmelCase				      =      AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'	)

     __lowerCAmelCase				      =      floats_list((3, 1_0_0_0)	)

     __lowerCAmelCase				      =      processor_wavaveca(lowercase__   ,    return_tensors='np'	)
     __lowerCAmelCase				      =      processor_auto(lowercase__   ,    return_tensors='np'	)

     for key in input_wavaveca.keys():
        self.assertAlmostEqual(input_wavaveca[key].sum()   ,    input_auto[key].sum()   ,    delta=1e-2	)

     __lowerCAmelCase				      =      self._get_dummy_logits()

     __lowerCAmelCase				      =      processor_wavaveca.batch_decode(lowercase__	)
     __lowerCAmelCase				      =      processor_auto.batch_decode(lowercase__	)

     self.assertListEqual(decoded_wavaveca.text   ,    decoded_auto.text	)






  def 							lowercase						(							self					:						List[Any]	)				->		Tuple:
     __lowerCAmelCase				      =      self.get_feature_extractor()
     __lowerCAmelCase				      =      self.get_tokenizer()
     __lowerCAmelCase				      =      self.get_decoder()

     __lowerCAmelCase				      =      WavaVecaProcessorWithLM(tokenizer=lowercase__   ,    feature_extractor=lowercase__   ,    decoder=lowercase__	)

     self.assertListEqual(
         processor.model_input_names   ,    feature_extractor.model_input_names   ,    msg='`processor` and `feature_extractor` model input names do not match'   ,    )






  @staticmethod
  def 							lowercase						(							lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						str	)				->		Tuple:
     __lowerCAmelCase				      =      [d[key] for d in offsets]
     return retrieved_list






  def 							lowercase						(							self					:						Optional[Any]	)				->		Optional[Any]:
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'	)
     __lowerCAmelCase				      =      self._get_dummy_logits()[0]

     __lowerCAmelCase				      =      processor.decode(lowercase__   ,    output_word_offsets=lowercase__	)
     # check Wav2Vec2CTCTokenizerOutput keys for word
     self.assertEqual(len(outputs.keys()	)   ,    4	)
     self.assertTrue('text' in outputs	)
     self.assertTrue('word_offsets' in outputs	)
     self.assertTrue(isinstance(lowercase__   ,    lowercase__	)	)

     self.assertEqual(' '.join(self.get_from_offsets(outputs['word_offsets']   ,    'word'	)	)   ,    outputs.text	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets']   ,    'word'	)   ,    ['<s>', '<s>', '</s>']	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets']   ,    'start_offset'	)   ,    [0, 2, 4]	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets']   ,    'end_offset'	)   ,    [1, 3, 5]	)






  def 							lowercase						(							self					:						List[str]	)				->		str:
     __lowerCAmelCase				      =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'	)
     __lowerCAmelCase				      =      self._get_dummy_logits()

     __lowerCAmelCase				      =      processor.batch_decode(lowercase__   ,    output_word_offsets=lowercase__	)

     # check Wav2Vec2CTCTokenizerOutput keys for word
     self.assertEqual(len(outputs.keys()	)   ,    4	)
     self.assertTrue('text' in outputs	)
     self.assertTrue('word_offsets' in outputs	)
     self.assertTrue(isinstance(lowercase__   ,    lowercase__	)	)

     self.assertListEqual(
         [' '.join(self.get_from_offsets(lowercase__   ,    'word'	)	) for o in outputs['word_offsets']]   ,    outputs.text	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]   ,    'word'	)   ,    ['<s>', '<s>', '</s>']	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]   ,    'start_offset'	)   ,    [0, 2, 4]	)
     self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]   ,    'end_offset'	)   ,    [1, 3, 5]	)






  @slow
  @require_torch
  @require_torchaudio
  def 							lowercase						(							self					:						Dict	)				->		Any:
     import torch

     __lowerCAmelCase				      =      load_dataset('common_voice'   ,    'en'   ,    split='train'   ,    streaming=lowercase__	)
     __lowerCAmelCase				      =      ds.cast_column('audio'   ,    datasets.Audio(sampling_rate=1_6_0_0_0	)	)
     __lowerCAmelCase				      =      iter(lowercase__	)
     __lowerCAmelCase				      =      next(lowercase__	)

     __lowerCAmelCase				      =      AutoProcessor.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'	)
     __lowerCAmelCase				      =      WavaVecaForCTC.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'	)

     # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
     __lowerCAmelCase				      =      processor(sample['audio']['array']   ,    return_tensors='pt'	).input_values

     with torch.no_grad():
        __lowerCAmelCase				      =      model(lowercase__	).logits.cpu().numpy()

     __lowerCAmelCase				      =      processor.decode(logits[0]   ,    output_word_offsets=lowercase__	)

     __lowerCAmelCase				      =      model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
     __lowerCAmelCase				      =      [
         {
             'start_time': d['start_offset'] * time_offset,
             'end_time': d['end_offset'] * time_offset,
             'word': d['word'],
         }
         for d in output['word_offsets']
     ]

     __lowerCAmelCase				      =      'WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL'

     # output words
     self.assertEqual(' '.join(self.get_from_offsets(lowercase__   ,    'word'	)	)   ,    lowercase__	)
     self.assertEqual(' '.join(self.get_from_offsets(lowercase__   ,    'word'	)	)   ,    output.text	)

     # output times
     __lowerCAmelCase				      =      torch.tensor(self.get_from_offsets(lowercase__   ,    'start_time'	)	)
     __lowerCAmelCase				      =      torch.tensor(self.get_from_offsets(lowercase__   ,    'end_time'	)	)

     # fmt: off
     __lowerCAmelCase				      =      torch.tensor([1.41_99, 1.65_99, 2.25_99, 3.0, 3.24, 3.59_99, 3.79_99, 4.09_99, 4.26, 4.94, 5.28, 5.65_99, 5.78, 5.94, 6.32, 6.53_99, 6.65_99]	)
     __lowerCAmelCase				      =      torch.tensor([1.53_99, 1.89_99, 2.9, 3.16, 3.53_99, 3.72, 4.01_99, 4.17_99, 4.76, 5.15_99, 5.55_99, 5.69_99, 5.86, 6.19_99, 6.38, 6.61_99, 6.94]	)
     # fmt: on

     self.assertTrue(torch.allclose(lowercase__   ,    lowercase__   ,    atol=0.01	)	)
     self.assertTrue(torch.allclose(lowercase__   ,    lowercase__   ,    atol=0.01	)	)


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_lowercase:	Any       			=		{'''configuration_swin''': ['''SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SwinConfig''', '''SwinOnnxConfig''']}


try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase:	str       			=		[
				    '''SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''SwinForImageClassification''',
				    '''SwinForMaskedImageModeling''',
				    '''SwinModel''',
				    '''SwinPreTrainedModel''',
				    '''SwinBackbone''',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase:	str       			=		[
				    '''TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFSwinForImageClassification''',
				    '''TFSwinForMaskedImageModeling''',
				    '''TFSwinModel''',
				    '''TFSwinPreTrainedModel''',
				]

if TYPE_CHECKING:
				from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_swin import (
								    SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SwinBackbone,
								    SwinForImageClassification,
								    SwinForMaskedImageModeling,
								    SwinModel,
								    SwinPreTrainedModel,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_swin import (
								    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFSwinForImageClassification,
								    TFSwinForMaskedImageModeling,
								    TFSwinModel,
								    TFSwinPreTrainedModel,
								)

else:
				import sys

				_lowercase:	Tuple       			=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






