






'''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   ):

      '''simple docstring'''







      UpperCamelCase       =  '''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
      UpperCamelCase       =  dict(zip(lowerCamelCase__ ,   range(len(lowerCamelCase__   )   )   )   )

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

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

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

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







   def       UpperCAmelCase				(			self ,   **lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  self.add_kwargs_tokens_map.copy()
      kwargs.update(lowerCamelCase__   )
      return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   **lowerCamelCase__   ):

      '''simple docstring'''







      return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   **lowerCamelCase__   ):

      '''simple docstring'''







      return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      shutil.rmtree(self.tmpdirname   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

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

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

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

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







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  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
      UpperCamelCase       =  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   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_tokenizer()
      # add token to trigger raise
      tokenizer.add_tokens(['''xx''']   )
      with self.assertRaisesRegex(lowerCamelCase__ ,   '''include'''   ):
         WavaVecaProcessorWithLM(
             tokenizer=lowerCamelCase__ ,   feature_extractor=self.get_feature_extractor() ,   decoder=self.get_decoder()   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

      UpperCamelCase       =  floats_list((3, 1_0_0_0)   )

      UpperCamelCase       =  feature_extractor(lowerCamelCase__ ,   return_tensors='''np'''   )
      UpperCamelCase       =  processor(lowerCamelCase__ ,   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   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

      UpperCamelCase       =  '''This is a test string'''

      UpperCamelCase       =  processor(text=lowerCamelCase__   )

      UpperCamelCase       =  tokenizer(lowerCamelCase__   )

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







   def       UpperCAmelCase				(			self ,   lowerCamelCase__=(2, 1_0, 1_6) ,   lowerCamelCase__=7_7   ):

      '''simple docstring'''







      np.random.seed(lowerCamelCase__   )
      return np.random.rand(*lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

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

      UpperCamelCase       =  processor.decode(lowerCamelCase__   )

      UpperCamelCase       =  decoder.decode_beams(lowerCamelCase__   )[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 ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

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

      UpperCamelCase       =  list(lowerCamelCase__   )

      with get_context('''fork'''   ).Pool() as p:
         UpperCamelCase       =  decoder.decode_beams_batch(lowerCamelCase__ ,   lowerCamelCase__   )

      UpperCamelCase     , UpperCamelCase     , UpperCamelCase       =  [], [], []
      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(lowerCamelCase__ ,   decoded_processor.text   )
      self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>'''] ,   decoded_processor.text   )
      self.assertListEqual(lowerCamelCase__ ,   decoded_processor.logit_score   )
      self.assertListEqual(lowerCamelCase__ ,   decoded_processor.lm_score   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

      UpperCamelCase       =  self._get_dummy_logits()

      UpperCamelCase       =  1_5
      UpperCamelCase       =  -20.0
      UpperCamelCase       =  -4.0

      UpperCamelCase       =  processor.batch_decode(
          lowerCamelCase__ ,   beam_width=lowerCamelCase__ ,   beam_prune_logp=lowerCamelCase__ ,   token_min_logp=lowerCamelCase__ ,   )
      UpperCamelCase       =  decoded_processor_out.text

      UpperCamelCase       =  list(lowerCamelCase__   )

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

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

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

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

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







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

      UpperCamelCase       =  self._get_dummy_logits()

      UpperCamelCase       =  2.0
      UpperCamelCase       =  5.0
      UpperCamelCase       =  -20.0
      UpperCamelCase       =  True

      UpperCamelCase       =  processor.batch_decode(
          lowerCamelCase__ ,   alpha=lowerCamelCase__ ,   beta=lowerCamelCase__ ,   unk_score_offset=lowerCamelCase__ ,   lm_score_boundary=lowerCamelCase__ ,   )
      UpperCamelCase       =  decoded_processor_out.text

      UpperCamelCase       =  list(lowerCamelCase__   )
      decoder.reset_params(
          alpha=lowerCamelCase__ ,   beta=lowerCamelCase__ ,   unk_score_offset=lowerCamelCase__ ,   lm_score_boundary=lowerCamelCase__ ,   )

      with get_context('''fork'''   ).Pool() as pool:
         UpperCamelCase       =  decoder.decode_beams_batch(
             lowerCamelCase__ ,   lowerCamelCase__ ,   )

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

      self.assertListEqual(lowerCamelCase__ ,   lowerCamelCase__   )
      self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>'''] ,   lowerCamelCase__   )
      UpperCamelCase       =  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 ,   lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )

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

      UpperCamelCase       =  os.listdir(lowerCamelCase__   )
      UpperCamelCase       =  ['''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(lowerCamelCase__ ,   lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  snapshot_download('''hf-internal-testing/processor_with_lm'''   )

      UpperCamelCase       =  WavaVecaProcessorWithLM.from_pretrained(lowerCamelCase__   )

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

      UpperCamelCase       =  os.listdir(lowerCamelCase__   )
      UpperCamelCase       =  os.listdir(lowerCamelCase__   )

      local_decoder_files.sort()
      expected_decoder_files.sort()

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







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )
      UpperCamelCase       =  AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''   )

      UpperCamelCase       =  floats_list((3, 1_0_0_0)   )

      UpperCamelCase       =  processor_wavaveca(lowerCamelCase__ ,   return_tensors='''np'''   )
      UpperCamelCase       =  processor_auto(lowerCamelCase__ ,   return_tensors='''np'''   )

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

      UpperCamelCase       =  self._get_dummy_logits()

      UpperCamelCase       =  processor_wavaveca.batch_decode(lowerCamelCase__   )
      UpperCamelCase       =  processor_auto.batch_decode(lowerCamelCase__   )

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







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.get_feature_extractor()
      UpperCamelCase       =  self.get_tokenizer()
      UpperCamelCase       =  self.get_decoder()

      UpperCamelCase       =  WavaVecaProcessorWithLM(tokenizer=lowerCamelCase__ ,   feature_extractor=lowerCamelCase__ ,   decoder=lowerCamelCase__   )

      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				(			lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  [d[key] for d in offsets]
      return retrieved_list







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )
      UpperCamelCase       =  self._get_dummy_logits()[0]

      UpperCamelCase       =  processor.decode(lowerCamelCase__ ,   output_word_offsets=lowerCamelCase__   )
      # 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(lowerCamelCase__ ,   lowerCamelCase__   )   )

      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   ):

      '''simple docstring'''







      UpperCamelCase       =  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )
      UpperCamelCase       =  self._get_dummy_logits()

      UpperCamelCase       =  processor.batch_decode(lowerCamelCase__ ,   output_word_offsets=lowerCamelCase__   )

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

      self.assertListEqual(
          [''' '''.join(self.get_from_offsets(lowerCamelCase__ ,   '''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   ):

      '''simple docstring'''







      import torch

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

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

      with torch.no_grad():
         UpperCamelCase       =  model(lowerCamelCase__   ).logits.cpu().numpy()

      UpperCamelCase       =  processor.decode(logits[0] ,   output_word_offsets=lowerCamelCase__   )

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

      UpperCamelCase       =  '''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(lowerCamelCase__ ,   '''word'''   )   ) ,   lowerCamelCase__   )
      self.assertEqual(''' '''.join(self.get_from_offsets(lowerCamelCase__ ,   '''word'''   )   ) ,   output.text   )

      # output times
      UpperCamelCase       =  torch.tensor(self.get_from_offsets(lowerCamelCase__ ,   '''start_time'''   )   )
      UpperCamelCase       =  torch.tensor(self.get_from_offsets(lowerCamelCase__ ,   '''end_time'''   )   )

      # fmt: off
      UpperCamelCase       =  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]   )
      UpperCamelCase       =  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(lowerCamelCase__ ,   lowerCamelCase__ ,   atol=0.01   )   )
      self.assertTrue(torch.allclose(lowerCamelCase__ ,   lowerCamelCase__ ,   atol=0.01   )   )







'''simple docstring'''


import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import DeformableDetrImageProcessor


class 						lowercase__	(  unittest.TestCase   ):






   '''simple docstring'''







   def __init__(			self ,   lowerCamelCase__ ,   lowerCamelCase__=7 ,   lowerCamelCase__=3 ,   lowerCamelCase__=3_0 ,   lowerCamelCase__=4_0_0 ,   lowerCamelCase__=True ,   lowerCamelCase__=None ,   lowerCamelCase__=True ,   lowerCamelCase__=[0.5, 0.5, 0.5] ,   lowerCamelCase__=[0.5, 0.5, 0.5] ,   lowerCamelCase__=True ,   lowerCamelCase__=1 / 2_5_5 ,   lowerCamelCase__=True ,   ):

      '''simple docstring'''







      UpperCamelCase       =  size if size is not None else {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}
      UpperCamelCase       =  parent
      UpperCamelCase       =  batch_size
      UpperCamelCase       =  num_channels
      UpperCamelCase       =  min_resolution
      UpperCamelCase       =  max_resolution
      UpperCamelCase       =  do_resize
      UpperCamelCase       =  size
      UpperCamelCase       =  do_normalize
      UpperCamelCase       =  image_mean
      UpperCamelCase       =  image_std
      UpperCamelCase       =  do_rescale
      UpperCamelCase       =  rescale_factor
      UpperCamelCase       =  do_pad







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return {
          "do_resize": self.do_resize,
          "size": self.size,
          "do_normalize": self.do_normalize,
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_rescale": self.do_rescale,
          "rescale_factor": self.rescale_factor,
          "do_pad": self.do_pad,
      }







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__=False   ):

      '''simple docstring'''







      if not batched:
         UpperCamelCase       =  image_inputs[0]
         if isinstance(lowerCamelCase__ ,   Image.Image   ):
            UpperCamelCase     , UpperCamelCase       =  image.size
         else:
            UpperCamelCase     , UpperCamelCase       =  image.shape[1], image.shape[2]
         if w < h:
            UpperCamelCase       =  int(self.size['''shortest_edge'''] * h / w   )
            UpperCamelCase       =  self.size['''shortest_edge''']
         elif w > h:
            UpperCamelCase       =  self.size['''shortest_edge''']
            UpperCamelCase       =  int(self.size['''shortest_edge'''] * w / h   )
         else:
            UpperCamelCase       =  self.size['''shortest_edge''']
            UpperCamelCase       =  self.size['''shortest_edge''']

      else:
         UpperCamelCase       =  []
         for image in image_inputs:
            UpperCamelCase     , UpperCamelCase       =  self.get_expected_values([image]   )
            expected_values.append((expected_height, expected_width)   )
         UpperCamelCase       =  max(lowerCamelCase__ ,   key=lambda lowerCamelCase__   : item[0]   )[0]
         UpperCamelCase       =  max(lowerCamelCase__ ,   key=lambda lowerCamelCase__   : item[1]   )[1]

      return expected_height, expected_width




@require_torch
@require_vision
class 						lowercase__	(  snake_case_,					unittest.TestCase   ):






   '''simple docstring'''







   _snake_case		   =							DeformableDetrImageProcessor if is_vision_available() else None







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  DeformableDetrImageProcessingTester(self   )







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return self.image_processor_tester.prepare_image_processor_dict()







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''image_mean'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''image_std'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''do_normalize'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''do_resize'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''do_rescale'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''do_pad'''   )   )
      self.assertTrue(hasattr(lowerCamelCase__ ,   '''size'''   )   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class.from_dict(self.image_processor_dict   )
      self.assertEqual(image_processor.size ,   {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}   )
      self.assertEqual(image_processor.do_pad ,   lowerCamelCase__   )

      UpperCamelCase       =  self.image_processing_class.from_dict(
          self.image_processor_dict ,   size=4_2 ,   max_size=8_4 ,   pad_and_return_pixel_mask=lowerCamelCase__   )
      self.assertEqual(image_processor.size ,   {'''shortest_edge''': 4_2, '''longest_edge''': 8_4}   )
      self.assertEqual(image_processor.do_pad ,   lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random PIL images
      UpperCamelCase       =  prepare_image_inputs(self.image_processor_tester ,   equal_resolution=lowerCamelCase__   )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase__ ,   Image.Image   )

      # Test not batched input
      UpperCamelCase       =  image_processing(image_inputs[0] ,   return_tensors='''pt'''   ).pixel_values

      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__   )

      self.assertEqual(
          encoded_images.shape ,   (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,   )

      # Test batched
      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__ ,   batched=lowerCamelCase__   )

      UpperCamelCase       =  image_processing(lowerCamelCase__ ,   return_tensors='''pt'''   ).pixel_values
      self.assertEqual(
          encoded_images.shape ,   (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          ) ,   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random numpy tensors
      UpperCamelCase       =  prepare_image_inputs(self.image_processor_tester ,   equal_resolution=lowerCamelCase__ ,   numpify=lowerCamelCase__   )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase__ ,   np.ndarray   )

      # Test not batched input
      UpperCamelCase       =  image_processing(image_inputs[0] ,   return_tensors='''pt'''   ).pixel_values

      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__   )

      self.assertEqual(
          encoded_images.shape ,   (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,   )

      # Test batched
      UpperCamelCase       =  image_processing(lowerCamelCase__ ,   return_tensors='''pt'''   ).pixel_values

      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__ ,   batched=lowerCamelCase__   )

      self.assertEqual(
          encoded_images.shape ,   (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          ) ,   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random PyTorch tensors
      UpperCamelCase       =  prepare_image_inputs(self.image_processor_tester ,   equal_resolution=lowerCamelCase__ ,   torchify=lowerCamelCase__   )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase__ ,   torch.Tensor   )

      # Test not batched input
      UpperCamelCase       =  image_processing(image_inputs[0] ,   return_tensors='''pt'''   ).pixel_values

      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__   )

      self.assertEqual(
          encoded_images.shape ,   (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,   )

      # Test batched
      UpperCamelCase       =  image_processing(lowerCamelCase__ ,   return_tensors='''pt'''   ).pixel_values

      UpperCamelCase     , UpperCamelCase       =  self.image_processor_tester.get_expected_values(lowerCamelCase__ ,   batched=lowerCamelCase__   )

      self.assertEqual(
          encoded_images.shape ,   (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          ) ,   )







   @slow
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
      with open('''./tests/fixtures/tests_samples/COCO/coco_annotations.txt''' ,   '''r'''   ) as f:
         UpperCamelCase       =  json.loads(f.read()   )

      UpperCamelCase       =  {'''image_id''': 3_9_7_6_9, '''annotations''': target}

      # encode them
      UpperCamelCase       =  DeformableDetrImageProcessor()
      UpperCamelCase       =  image_processing(images=lowerCamelCase__ ,   annotations=lowerCamelCase__ ,   return_tensors='''pt'''   )

      # verify pixel values
      UpperCamelCase       =  torch.Size([1, 3, 8_0_0, 1_0_6_6]   )
      self.assertEqual(encoding['''pixel_values'''].shape ,   lowerCamelCase__   )

      UpperCamelCase       =  torch.tensor([0.2796, 0.3138, 0.3481]   )
      self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] ,   lowerCamelCase__ ,   atol=1e-4   )   )

      # verify area
      UpperCamelCase       =  torch.tensor([5887.9600, 11250.2061, 489353.8438, 837122.7500, 147967.5156, 165732.3438]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] ,   lowerCamelCase__   )   )
      # verify boxes
      UpperCamelCase       =  torch.Size([6, 4]   )
      self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape ,   lowerCamelCase__   )
      UpperCamelCase       =  torch.tensor([0.5503, 0.2765, 0.0604, 0.2215]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] ,   lowerCamelCase__ ,   atol=1e-3   )   )
      # verify image_id
      UpperCamelCase       =  torch.tensor([3_9_7_6_9]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] ,   lowerCamelCase__   )   )
      # verify is_crowd
      UpperCamelCase       =  torch.tensor([0, 0, 0, 0, 0, 0]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] ,   lowerCamelCase__   )   )
      # verify class_labels
      UpperCamelCase       =  torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] ,   lowerCamelCase__   )   )
      # verify orig_size
      UpperCamelCase       =  torch.tensor([4_8_0, 6_4_0]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] ,   lowerCamelCase__   )   )
      # verify size
      UpperCamelCase       =  torch.tensor([8_0_0, 1_0_6_6]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] ,   lowerCamelCase__   )   )







   @slow
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
      with open('''./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt''' ,   '''r'''   ) as f:
         UpperCamelCase       =  json.loads(f.read()   )

      UpperCamelCase       =  {'''file_name''': '''000000039769.png''', '''image_id''': 3_9_7_6_9, '''segments_info''': target}

      UpperCamelCase       =  pathlib.Path('''./tests/fixtures/tests_samples/COCO/coco_panoptic'''   )

      # encode them
      UpperCamelCase       =  DeformableDetrImageProcessor(format='''coco_panoptic'''   )
      UpperCamelCase       =  image_processing(images=lowerCamelCase__ ,   annotations=lowerCamelCase__ ,   masks_path=lowerCamelCase__ ,   return_tensors='''pt'''   )

      # verify pixel values
      UpperCamelCase       =  torch.Size([1, 3, 8_0_0, 1_0_6_6]   )
      self.assertEqual(encoding['''pixel_values'''].shape ,   lowerCamelCase__   )

      UpperCamelCase       =  torch.tensor([0.2796, 0.3138, 0.3481]   )
      self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] ,   lowerCamelCase__ ,   atol=1e-4   )   )

      # verify area
      UpperCamelCase       =  torch.tensor([147979.6875, 165527.0469, 484638.5938, 11292.9375, 5879.6562, 7634.1147]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] ,   lowerCamelCase__   )   )
      # verify boxes
      UpperCamelCase       =  torch.Size([6, 4]   )
      self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape ,   lowerCamelCase__   )
      UpperCamelCase       =  torch.tensor([0.2625, 0.5437, 0.4688, 0.8625]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] ,   lowerCamelCase__ ,   atol=1e-3   )   )
      # verify image_id
      UpperCamelCase       =  torch.tensor([3_9_7_6_9]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] ,   lowerCamelCase__   )   )
      # verify is_crowd
      UpperCamelCase       =  torch.tensor([0, 0, 0, 0, 0, 0]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] ,   lowerCamelCase__   )   )
      # verify class_labels
      UpperCamelCase       =  torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] ,   lowerCamelCase__   )   )
      # verify masks
      UpperCamelCase       =  8_2_2_8_7_3
      self.assertEqual(encoding['''labels'''][0]['''masks'''].sum().item() ,   lowerCamelCase__   )
      # verify orig_size
      UpperCamelCase       =  torch.tensor([4_8_0, 6_4_0]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] ,   lowerCamelCase__   )   )
      # verify size
      UpperCamelCase       =  torch.tensor([8_0_0, 1_0_6_6]   )
      self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] ,   lowerCamelCase__   )   )





