



'''simple docstring'''






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 							a__( unittest.TestCase     ):







    def       lowercase_	(				self			:  int     ):
      a						: Dict					       =					'| <pad> <unk> <s> </s> a b c d e f g h i j k'.split()
      a						: Union[str, Any]					       =					dict(zip(UpperCamelCase__						,      range(len(UpperCamelCase__     )     )     )     )

      a						: Union[str, Any]					       =					{
          'unk_token': '<unk>',
          'bos_token': '<s>',
          'eos_token': '</s>',
      }
      a						: Union[str, Any]					       =					{
          'feature_size': 1,
          'padding_value': 0.0,
          'sampling_rate': 1_60_00,
          'return_attention_mask': False,
          'do_normalize': True,
      }

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

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

      # load decoder from hub
      a						: Union[str, Any]					       =					'hf-internal-testing/ngram-beam-search-decoder'







    def       lowercase_	(				self			:  Tuple						,      **__snake_case			:  Tuple     ):
      a						: Any					       =					self.add_kwargs_tokens_map.copy()
      kwargs.update(UpperCamelCase__     )
      return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname						,      **UpperCamelCase__     )







    def       lowercase_	(				self			:  Union[str, Any]						,      **__snake_case			:  List[Any]     ):
      return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname						,      **UpperCamelCase__     )







    def       lowercase_	(				self			:  List[Any]						,      **__snake_case			:  Union[str, Any]     ):
      return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name						,      **UpperCamelCase__     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      shutil.rmtree(self.tmpdirname     )







    def       lowercase_	(				self			:  Tuple     ):
      a						: Tuple					       =					self.get_tokenizer()
      a						: List[str]					       =					self.get_feature_extractor()
      a						: List[str]					       =					self.get_decoder()

      a						: int					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      processor.save_pretrained(self.tmpdirname     )
      a						: str					       =					WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname     )

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

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

      # 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						,      UpperCamelCase__     )







    def       lowercase_	(				self			:  Optional[int]     ):
      a						: Tuple					       =					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
      a						: Tuple					       =					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			:  Optional[int]     ):
      a						: Optional[int]					       =					self.get_tokenizer()
      # add token to trigger raise
      tokenizer.add_tokens(['xx']     )
      with self.assertRaisesRegex(UpperCamelCase__						,      'include'     ):
        WavaVecaProcessorWithLM(
            tokenizer=UpperCamelCase__						,      feature_extractor=self.get_feature_extractor()						,      decoder=self.get_decoder()     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: Any					       =					self.get_feature_extractor()
      a						: List[Any]					       =					self.get_tokenizer()
      a						: int					       =					self.get_decoder()

      a						: List[Any]					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: str					       =					floats_list((3, 10_00)     )

      a						: str					       =					feature_extractor(UpperCamelCase__						,      return_tensors='np'     )
      a						: Optional[Any]					       =					processor(UpperCamelCase__						,      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			:  List[str]     ):
      a						: List[Any]					       =					self.get_feature_extractor()
      a						: List[Any]					       =					self.get_tokenizer()
      a						: int					       =					self.get_decoder()

      a						: Any					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: Optional[int]					       =					'This is a test string'

      a						: Union[str, Any]					       =					processor(text=UpperCamelCase__     )

      a						: Optional[Any]					       =					tokenizer(UpperCamelCase__     )

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







    def       lowercase_	(				self			:  Union[str, Any]						,      __snake_case			:  List[str]=(2, 10, 16)						,      __snake_case			:  Union[str, Any]=77     ):
      np.random.seed(UpperCamelCase__     )
      return np.random.rand(*UpperCamelCase__     )







    def       lowercase_	(				self			:  int     ):
      a						: Optional[int]					       =					self.get_feature_extractor()
      a						: Dict					       =					self.get_tokenizer()
      a						: List[str]					       =					self.get_decoder()

      a						: List[str]					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: str					       =					self._get_dummy_logits(shape=(10, 16)						,      seed=13     )

      a						: Optional[Any]					       =					processor.decode(UpperCamelCase__     )

      a						: Tuple					       =					decoder.decode_beams(UpperCamelCase__     )[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			:  Dict						,      __snake_case			:  Optional[Any]     ):
      a						: int					       =					self.get_feature_extractor()
      a						: Dict					       =					self.get_tokenizer()
      a						: Optional[int]					       =					self.get_decoder()

      a						: str					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: Optional[Any]					       =					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:
        a						: List[str]					       =					processor.batch_decode(UpperCamelCase__     )
      else:
        with get_context(UpperCamelCase__     ).Pool() as pool:
          a						: Dict					       =					processor.batch_decode(UpperCamelCase__						,      UpperCamelCase__     )

      a						: Optional[Any]					       =					list(UpperCamelCase__     )

      with get_context('fork'     ).Pool() as p:
        a						: Tuple					       =					decoder.decode_beams_batch(UpperCamelCase__						,      UpperCamelCase__     )

      a       ,     a       ,     a						: Optional[int]					       =					[], [], []
      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(UpperCamelCase__						,      decoded_processor.text     )
      self.assertListEqual(['<s> <s> </s>', '<s> <s> <s>']						,      decoded_processor.text     )
      self.assertListEqual(UpperCamelCase__						,      decoded_processor.logit_score     )
      self.assertListEqual(UpperCamelCase__						,      decoded_processor.lm_score     )







    def       lowercase_	(				self			:  Dict     ):
      a						: List[str]					       =					self.get_feature_extractor()
      a						: List[str]					       =					self.get_tokenizer()
      a						: Dict					       =					self.get_decoder()

      a						: Union[str, Any]					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: str					       =					self._get_dummy_logits()

      a						: List[Any]					       =					15
      a						: int					       =					-20.0
      a						: Tuple					       =					-4.0

      a						: List[str]					       =					processor.batch_decode(
          UpperCamelCase__						,      beam_width=UpperCamelCase__						,      beam_prune_logp=UpperCamelCase__						,      token_min_logp=UpperCamelCase__						,      )
      a						: Tuple					       =					decoded_processor_out.text

      a						: Union[str, Any]					       =					list(UpperCamelCase__     )

      with get_context('fork'     ).Pool() as pool:
        a						: Optional[Any]					       =					decoder.decode_beams_batch(
            UpperCamelCase__						,      UpperCamelCase__						,      beam_width=UpperCamelCase__						,      beam_prune_logp=UpperCamelCase__						,      token_min_logp=UpperCamelCase__						,      )

      a						: Optional[int]					       =					[d[0][0] for d in decoded_decoder_out]
      a						: Any					       =					[d[0][2] for d in decoded_decoder_out]
      a						: Optional[Any]					       =					[d[0][3] for d in decoded_decoder_out]

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

      self.assertTrue(np.array_equal(UpperCamelCase__						,      decoded_processor_out.logit_score     )     )
      self.assertTrue(np.allclose([-20.054, -18.447]						,      UpperCamelCase__						,      atol=1e-3     )     )

      self.assertTrue(np.array_equal(UpperCamelCase__						,      decoded_processor_out.lm_score     )     )
      self.assertTrue(np.allclose([-15.554, -13.9474]						,      UpperCamelCase__						,      atol=1e-3     )     )







    def       lowercase_	(				self			:  Any     ):
      a						: Dict					       =					self.get_feature_extractor()
      a						: Optional[int]					       =					self.get_tokenizer()
      a						: int					       =					self.get_decoder()

      a						: Any					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      a						: Dict					       =					self._get_dummy_logits()

      a						: List[Any]					       =					2.0
      a						: int					       =					5.0
      a						: List[str]					       =					-20.0
      a						: Union[str, Any]					       =					True

      a						: List[Any]					       =					processor.batch_decode(
          UpperCamelCase__						,      alpha=UpperCamelCase__						,      beta=UpperCamelCase__						,      unk_score_offset=UpperCamelCase__						,      lm_score_boundary=UpperCamelCase__						,      )
      a						: Any					       =					decoded_processor_out.text

      a						: str					       =					list(UpperCamelCase__     )
      decoder.reset_params(
          alpha=UpperCamelCase__						,      beta=UpperCamelCase__						,      unk_score_offset=UpperCamelCase__						,      lm_score_boundary=UpperCamelCase__						,      )

      with get_context('fork'     ).Pool() as pool:
        a						: str					       =					decoder.decode_beams_batch(
            UpperCamelCase__						,      UpperCamelCase__						,      )

      a						: str					       =					[d[0][0] for d in decoded_decoder_out]

      self.assertListEqual(UpperCamelCase__						,      UpperCamelCase__     )
      self.assertListEqual(['<s> </s> <s> </s> </s>', '</s> </s> <s> </s> </s>']						,      UpperCamelCase__     )
      a						: Dict					       =					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						,      -20.0     )
      self.assertEqual(lm_model.score_boundary						,      UpperCamelCase__     )







    def       lowercase_	(				self			:  Dict     ):
      a						: Optional[Any]					       =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )

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

      a						: Dict					       =					os.listdir(UpperCamelCase__     )
      a						: Tuple					       =					['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(UpperCamelCase__						,      UpperCamelCase__     )







    def       lowercase_	(				self			:  List[str]     ):
      a						: Any					       =					snapshot_download('hf-internal-testing/processor_with_lm'     )

      a						: Tuple					       =					WavaVecaProcessorWithLM.from_pretrained(UpperCamelCase__     )

      a						: Any					       =					processor.decoder.model_container[processor.decoder._model_key]
      a						: Optional[int]					       =					Path(language_model._kenlm_model.path.decode('utf-8'     )     ).parent.parent.absolute()

      a						: int					       =					os.listdir(UpperCamelCase__     )
      a						: Optional[int]					       =					os.listdir(UpperCamelCase__     )

      local_decoder_files.sort()
      expected_decoder_files.sort()

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







    def       lowercase_	(				self			:  Optional[int]     ):
      a						: Dict					       =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )
      a						: int					       =					AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'     )

      a						: List[Any]					       =					floats_list((3, 10_00)     )

      a						: str					       =					processor_wavaveca(UpperCamelCase__						,      return_tensors='np'     )
      a						: List[Any]					       =					processor_auto(UpperCamelCase__						,      return_tensors='np'     )

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

      a						: Optional[Any]					       =					self._get_dummy_logits()

      a						: int					       =					processor_wavaveca.batch_decode(UpperCamelCase__     )
      a						: List[str]					       =					processor_auto.batch_decode(UpperCamelCase__     )

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







    def       lowercase_	(				self			:  List[Any]     ):
      a						: str					       =					self.get_feature_extractor()
      a						: Optional[Any]					       =					self.get_tokenizer()
      a						: Tuple					       =					self.get_decoder()

      a						: Optional[int]					       =					WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__						,      feature_extractor=UpperCamelCase__						,      decoder=UpperCamelCase__     )

      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_	(				__snake_case			:  Optional[Any]						,      __snake_case			:  Optional[Any]     ):
      a						: Optional[Any]					       =					[d[key] for d in offsets]
      return retrieved_list







    def       lowercase_	(				self			:  Dict     ):
      a						: Optional[int]					       =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )
      a						: Optional[Any]					       =					self._get_dummy_logits()[0]

      a						: Any					       =					processor.decode(UpperCamelCase__						,      output_word_offsets=UpperCamelCase__     )
      # 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(UpperCamelCase__						,      UpperCamelCase__     )     )

      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[Any]     ):
      a						: int					       =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )
      a						: Any					       =					self._get_dummy_logits()

      a						: Union[str, Any]					       =					processor.batch_decode(UpperCamelCase__						,      output_word_offsets=UpperCamelCase__     )

      # 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(UpperCamelCase__						,      UpperCamelCase__     )     )

      self.assertListEqual(
          [' '.join(self.get_from_offsets(UpperCamelCase__						,      '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			:  Optional[int]     ):
      import torch

      a						: Any					       =					load_dataset('common_voice'						,      'en'						,      split='train'						,      streaming=UpperCamelCase__     )
      a						: Tuple					       =					ds.cast_column('audio'						,      datasets.Audio(sampling_rate=1_60_00     )     )
      a						: Union[str, Any]					       =					iter(UpperCamelCase__     )
      a						: Optional[Any]					       =					next(UpperCamelCase__     )

      a						: Optional[Any]					       =					AutoProcessor.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'     )
      a						: str					       =					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
      a						: Tuple					       =					processor(sample['audio']['array']						,      return_tensors='pt'     ).input_values

      with torch.no_grad():
        a						: List[Any]					       =					model(UpperCamelCase__     ).logits.cpu().numpy()

      a						: Any					       =					processor.decode(logits[0]						,      output_word_offsets=UpperCamelCase__     )

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

      a						: Any					       =					'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(UpperCamelCase__						,      'word'     )     )						,      UpperCamelCase__     )
      self.assertEqual(' '.join(self.get_from_offsets(UpperCamelCase__						,      'word'     )     )						,      output.text     )

      # output times
      a						: int					       =					torch.tensor(self.get_from_offsets(UpperCamelCase__						,      'start_time'     )     )
      a						: Any					       =					torch.tensor(self.get_from_offsets(UpperCamelCase__						,      'end_time'     )     )

      # fmt: off
      a						: List[Any]					       =					torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]     )
      a						: Optional[int]					       =					torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]     )
      # fmt: on

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




'''simple docstring'''






from typing import TYPE_CHECKING

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


lowerCAmelCase: Any							=						{
    'configuration_poolformer': [
        'POOLFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'PoolFormerConfig',
        'PoolFormerOnnxConfig',
    ]
}

try:
     if not is_vision_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase: List[str]							=						['PoolFormerFeatureExtractor']
     lowerCAmelCase: Tuple							=						['PoolFormerImageProcessor']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase: str							=						[
         'POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'PoolFormerForImageClassification',
         'PoolFormerModel',
         'PoolFormerPreTrainedModel',
     ]


if TYPE_CHECKING:
     from .configuration_poolformer import (
         POOLFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
         PoolFormerConfig,
         PoolFormerOnnxConfig,
     )

     try:
          if not is_vision_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .feature_extraction_poolformer import PoolFormerFeatureExtractor
          from .image_processing_poolformer import PoolFormerImageProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_poolformer import (
              POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              PoolFormerForImageClassification,
              PoolFormerModel,
              PoolFormerPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase: Dict							=						_LazyModule(__name__, globals()['__file__'], _import_structure)