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







   """simple docstring"""

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

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

        _A    		=  tempfile.mkdtemp()
        _A    		=  os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['vocab_file']     )
        _A    		=  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    		=  'hf-internal-testing/ngram-beam-search-decoder'
   def 	__UpperCAmelCase   (      self      :			int, **UpperCamelCase__      :			Tuple     )  ->			Any:
        _A    		=  self.add_kwargs_tokens_map.copy()
        kwargs.update(UpperCamelCase__     )
        return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname, **UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			int, **UpperCamelCase__      :			Dict     )  ->			str:
        return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname, **UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			Tuple, **UpperCamelCase__      :			Dict     )  ->			Optional[Any]:
        return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name, **UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			Union[str, Any]     )  ->			Optional[Any]:
        shutil.rmtree(self.tmpdirname     )
   def 	__UpperCAmelCase   (      self      :			List[str]     )  ->			List[Any]:
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        processor.save_pretrained(self.tmpdirname     )
        _A    		=  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 	__UpperCAmelCase   (      self      :			Dict     )  ->			Union[str, Any]:
        _A    		=  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    		=  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 	__UpperCAmelCase   (      self      :			Optional[Any]     )  ->			List[str]:
        _A    		=  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 	__UpperCAmelCase   (      self      :			Any     )  ->			Optional[int]:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  floats_list((3, 10_00)     )

        _A    		=  feature_extractor(UpperCamelCase__, return_tensors='np'     )
        _A    		=  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 	__UpperCAmelCase   (      self      :			str     )  ->			Tuple:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  'This is a test string'

        _A    		=  processor(text=UpperCamelCase__     )

        _A    		=  tokenizer(UpperCamelCase__     )

        for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key], encoded_processor[key]     )
   def 	__UpperCAmelCase   (      self      :			Tuple, UpperCamelCase__      :			Dict=(2, 10, 16), UpperCamelCase__      :			Optional[Any]=77     )  ->			List[Any]:
        np.random.seed(UpperCamelCase__     )
        return np.random.rand(*UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			Tuple     )  ->			List[str]:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  self._get_dummy_logits(shape=(10, 16), seed=13     )

        _A    		=  processor.decode(UpperCamelCase__     )

        _A    		=  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 	__UpperCAmelCase   (      self      :			List[str], UpperCamelCase__      :			List[Any]     )  ->			str:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  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    		=  processor.batch_decode(UpperCamelCase__     )
        else:
             with get_context(UpperCamelCase__     ).Pool() as pool:
                  _A    		=  processor.batch_decode(UpperCamelCase__, UpperCamelCase__     )

        _A    		=  list(UpperCamelCase__     )

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

        _A		,       _A		,       _A    		=  [], [], []
        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 	__UpperCAmelCase   (      self      :			str     )  ->			Dict:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  self._get_dummy_logits()

        _A    		=  15
        _A    		=  -20.0
        _A    		=  -4.0

        _A    		=  processor.batch_decode(
            UpperCamelCase__, beam_width=UpperCamelCase__, beam_prune_logp=UpperCamelCase__, token_min_logp=UpperCamelCase__, )
        _A    		=  decoded_processor_out.text

        _A    		=  list(UpperCamelCase__     )

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

        _A    		=  [d[0][0] for d in decoded_decoder_out]
        _A    		=  [d[0][2] for d in decoded_decoder_out]
        _A    		=  [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.9_474], UpperCamelCase__, atol=1e-3     )     )
   def 	__UpperCAmelCase   (      self      :			Any     )  ->			str:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  WavaVecaProcessorWithLM(tokenizer=UpperCamelCase__, feature_extractor=UpperCamelCase__, decoder=UpperCamelCase__     )

        _A    		=  self._get_dummy_logits()

        _A    		=  2.0
        _A    		=  5.0
        _A    		=  -20.0
        _A    		=  True

        _A    		=  processor.batch_decode(
            UpperCamelCase__, alpha=UpperCamelCase__, beta=UpperCamelCase__, unk_score_offset=UpperCamelCase__, lm_score_boundary=UpperCamelCase__, )
        _A    		=  decoded_processor_out.text

        _A    		=  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    		=  decoder.decode_beams_batch(
                 UpperCamelCase__, UpperCamelCase__, )

        _A    		=  [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    		=  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 	__UpperCAmelCase   (      self      :			int     )  ->			Dict:
        _A    		=  WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )

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

        _A    		=  os.listdir(UpperCamelCase__     )
        _A    		=  ['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 	__UpperCAmelCase   (      self      :			List[str]     )  ->			Tuple:
        _A    		=  snapshot_download('hf-internal-testing/processor_with_lm'     )

        _A    		=  WavaVecaProcessorWithLM.from_pretrained(UpperCamelCase__     )

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

        _A    		=  os.listdir(UpperCamelCase__     )
        _A    		=  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 	__UpperCAmelCase   (      self      :			int     )  ->			Optional[Any]:
        _A    		=  WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )
        _A    		=  AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'     )

        _A    		=  floats_list((3, 10_00)     )

        _A    		=  processor_wavaveca(UpperCamelCase__, return_tensors='np'     )
        _A    		=  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    		=  self._get_dummy_logits()

        _A    		=  processor_wavaveca.batch_decode(UpperCamelCase__     )
        _A    		=  processor_auto.batch_decode(UpperCamelCase__     )

        self.assertListEqual(decoded_wavaveca.text, decoded_auto.text     )
   def 	__UpperCAmelCase   (      self      :			List[str]     )  ->			Any:
        _A    		=  self.get_feature_extractor()
        _A    		=  self.get_tokenizer()
        _A    		=  self.get_decoder()

        _A    		=  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 	__UpperCAmelCase   (      UpperCamelCase__      :			str, UpperCamelCase__      :			List[str]     )  ->			Optional[Any]:
        _A    		=  [d[key] for d in offsets]
        return retrieved_list
   def 	__UpperCAmelCase   (      self      :			List[str]     )  ->			Union[str, Any]:
        _A    		=  WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'     )
        _A    		=  self._get_dummy_logits()[0]

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

        _A    		=  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 	__UpperCAmelCase   (      self      :			List[Any]     )  ->			List[str]:
        import torch

        _A    		=  load_dataset('common_voice', 'en', split='train', streaming=UpperCamelCase__     )
        _A    		=  ds.cast_column('audio', datasets.Audio(sampling_rate=1_60_00     )     )
        _A    		=  iter(UpperCamelCase__     )
        _A    		=  next(UpperCamelCase__     )

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

        with torch.no_grad():
             _A    		=  model(UpperCamelCase__     ).logits.cpu().numpy()

        _A    		=  processor.decode(logits[0], output_word_offsets=UpperCamelCase__     )

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

        _A    		=  '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    		=  torch.tensor(self.get_from_offsets(UpperCamelCase__, 'start_time'     )     )
        _A    		=  torch.tensor(self.get_from_offsets(UpperCamelCase__, 'end_time'     )     )

        # fmt: off
        _A    		=  torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]     )
        _A    		=  torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 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


_UpperCAmelCase    :     Any         =       {
    '''configuration_maskformer''': ['''MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MaskFormerConfig'''],
    '''configuration_maskformer_swin''': ['''MaskFormerSwinConfig'''],
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase    :     str         =       ['''MaskFormerFeatureExtractor''']
   _UpperCAmelCase    :     str         =       ['''MaskFormerImageProcessor''']


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase    :     Tuple         =       [
       '''MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''MaskFormerForInstanceSegmentation''',
       '''MaskFormerModel''',
       '''MaskFormerPreTrainedModel''',
   ]
   _UpperCAmelCase    :     int         =       [
       '''MaskFormerSwinBackbone''',
       '''MaskFormerSwinModel''',
       '''MaskFormerSwinPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_maskformer import MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskFormerConfig
   from .configuration_maskformer_swin import MaskFormerSwinConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_maskformer import MaskFormerFeatureExtractor
      from .image_processing_maskformer import MaskFormerImageProcessor
   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_maskformer import (
          MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          MaskFormerForInstanceSegmentation,
          MaskFormerModel,
          MaskFormerPreTrainedModel,
      )
      from .modeling_maskformer_swin import (
          MaskFormerSwinBackbone,
          MaskFormerSwinModel,
          MaskFormerSwinPreTrainedModel,
      )


else:
   import sys

   _UpperCAmelCase    :     str         =       _LazyModule(__name__, globals()['''__file__'''], _import_structure)



