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


			'''simple docstring'''






			def 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    {
					    """unk_token""": """<unk>""",
					    """bos_token""": """<s>""",
					    """eos_token""": """</s>""",
					}
					lowerCAmelCase     =    {
					    """feature_size""": 1,
					    """padding_value""": 0.0,
					    """sampling_rate""": 16000,
					    """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			,       __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
					lowerCAmelCase     =    """hf-internal-testing/ngram-beam-search-decoder"""



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    self.add_kwargs_tokens_map.copy()
					kwargs.update(__lowerCAmelCase)
					return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname			,       **__lowerCAmelCase)



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self):




					"""simple docstring"""


					shutil.rmtree(self.tmpdirname)



			def 				a_			(  self):




					"""simple docstring"""


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

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

					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			,       __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 				a_			(  self):




					"""simple docstring"""


					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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


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

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

					lowerCAmelCase     =    floats_list((3, 1000))

					lowerCAmelCase     =    feature_extractor(__lowerCAmelCase			,       return_tensors="""np""")
					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


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

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

					lowerCAmelCase     =    """This is a test string"""

					lowerCAmelCase     =    processor(text=__lowerCAmelCase)

					lowerCAmelCase     =    tokenizer(__lowerCAmelCase)

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



			def 				a_			(  self			,       __lowerCAmelCase=(2, 10, 16)			,       __lowerCAmelCase=77):




					"""simple docstring"""


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



			def 				a_			(  self):




					"""simple docstring"""


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

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

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

					lowerCAmelCase     =    processor.decode(__lowerCAmelCase)

					lowerCAmelCase     =    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 				a_			(  self			,       __lowerCAmelCase):




					"""simple docstring"""


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

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

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

					lowerCAmelCase     =    list(__lowerCAmelCase)

					with get_context("""fork""").Pool() as p:
							lowerCAmelCase     =    decoder.decode_beams_batch(__lowerCAmelCase			,       __lowerCAmelCase)

					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(__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 				a_			(  self):




					"""simple docstring"""


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

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

					lowerCAmelCase     =    self._get_dummy_logits()

					lowerCAmelCase     =    15
					lowerCAmelCase     =    -20.0
					lowerCAmelCase     =    -4.0

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

					lowerCAmelCase     =    list(__lowerCAmelCase)

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

					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(__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 				a_			(  self):




					"""simple docstring"""


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

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

					lowerCAmelCase     =    self._get_dummy_logits()

					lowerCAmelCase     =    2.0
					lowerCAmelCase     =    5.0
					lowerCAmelCase     =    -20.0
					lowerCAmelCase     =    True

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

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

					with get_context("""fork""").Pool() as pool:
							lowerCAmelCase     =    decoder.decode_beams_batch(
							    __lowerCAmelCase			,       __lowerCAmelCase			,       )

					lowerCAmelCase     =    [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)
					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			,       -20.0)
					self.assertEqual(lm_model.score_boundary			,       __lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					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(__lowerCAmelCase)
					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(__lowerCAmelCase			,       __lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    snapshot_download("""hf-internal-testing/processor_with_lm""")

					lowerCAmelCase     =    WavaVecaProcessorWithLM.from_pretrained(__lowerCAmelCase)

					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(__lowerCAmelCase)
					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""")
					lowerCAmelCase     =    AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""")

					lowerCAmelCase     =    floats_list((3, 1000))

					lowerCAmelCase     =    processor_wavaveca(__lowerCAmelCase			,       return_tensors="""np""")
					lowerCAmelCase     =    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)

					lowerCAmelCase     =    self._get_dummy_logits()

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

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



			def 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    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 				a_			(  __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""")
					lowerCAmelCase     =    self._get_dummy_logits()

					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					import torch

					lowerCAmelCase     =    load_dataset("""common_voice"""			,       """en"""			,       split="""train"""			,       streaming=__lowerCAmelCase)
					lowerCAmelCase     =    ds.cast_column("""audio"""			,       datasets.Audio(sampling_rate=16000))
					lowerCAmelCase     =    iter(__lowerCAmelCase)
					lowerCAmelCase     =    next(__lowerCAmelCase)

					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(__lowerCAmelCase).logits.cpu().numpy()

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

					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(__lowerCAmelCase			,       """word"""))			,       __lowerCAmelCase)
					self.assertEqual(""" """.join(self.get_from_offsets(__lowerCAmelCase			,       """word"""))			,       output.text)

					# output times
					lowerCAmelCase     =    torch.tensor(self.get_from_offsets(__lowerCAmelCase			,       """start_time"""))
					lowerCAmelCase     =    torch.tensor(self.get_from_offsets(__lowerCAmelCase			,       """end_time"""))

					# fmt: off
					lowerCAmelCase     =    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])
					lowerCAmelCase     =    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'''




from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
						import PIL


__lowercase        =    logging.get_logger(__name__)






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[Any]						=			['''pixel_values''']



			def __init__(  self			,       __lowerCAmelCase = True			,       __lowerCAmelCase = None			,       __lowerCAmelCase = PILImageResampling.BICUBIC			,       __lowerCAmelCase = True			,       __lowerCAmelCase = 1 / 255			,       __lowerCAmelCase = True			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = True			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					super().__init__(**__lowerCAmelCase)
					lowerCAmelCase     =    size if size is not None else {"""height""": 384, """width""": 384}
					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)

					lowerCAmelCase     =    do_resize
					lowerCAmelCase     =    size
					lowerCAmelCase     =    resample
					lowerCAmelCase     =    do_rescale
					lowerCAmelCase     =    rescale_factor
					lowerCAmelCase     =    do_normalize
					lowerCAmelCase     =    image_mean if image_mean is not None else OPENAI_CLIP_MEAN
					lowerCAmelCase     =    image_std if image_std is not None else OPENAI_CLIP_STD
					lowerCAmelCase     =    do_convert_rgb



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = PILImageResampling.BICUBIC			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)
					if "height" not in size or "width" not in size:
							raise ValueError(f"The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}")
					lowerCAmelCase     =    (size["""height"""], size["""width"""])
					return resize(__lowerCAmelCase			,       size=__lowerCAmelCase			,       resample=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					return rescale(__lowerCAmelCase			,       scale=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					return normalize(__lowerCAmelCase			,       mean=__lowerCAmelCase			,       std=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)







			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = ChannelDimension.FIRST			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    do_resize if do_resize is not None else self.do_resize
					lowerCAmelCase     =    resample if resample is not None else self.resample
					lowerCAmelCase     =    do_rescale if do_rescale is not None else self.do_rescale
					lowerCAmelCase     =    rescale_factor if rescale_factor is not None else self.rescale_factor
					lowerCAmelCase     =    do_normalize if do_normalize is not None else self.do_normalize
					lowerCAmelCase     =    image_mean if image_mean is not None else self.image_mean
					lowerCAmelCase     =    image_std if image_std is not None else self.image_std
					lowerCAmelCase     =    do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

					lowerCAmelCase     =    size if size is not None else self.size
					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)

					lowerCAmelCase     =    make_list_of_images(__lowerCAmelCase)

					if not valid_images(__lowerCAmelCase):
							raise ValueError(
							    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
							    """torch.Tensor, tf.Tensor or jax.ndarray.""")

					if do_resize and size is None or resample is None:
							raise ValueError("""Size and resample must be specified if do_resize is True.""")

					if do_rescale and rescale_factor is None:
							raise ValueError("""Rescale factor must be specified if do_rescale is True.""")

					if do_normalize and (image_mean is None or image_std is None):
							raise ValueError("""Image mean and std must be specified if do_normalize is True.""")

					# PIL RGBA images are converted to RGB
					if do_convert_rgb:
							lowerCAmelCase     =    [convert_to_rgb(__lowerCAmelCase) for image in images]

					# All transformations expect numpy arrays.
					lowerCAmelCase     =    [to_numpy_array(__lowerCAmelCase) for image in images]

					if do_resize:
							lowerCAmelCase     =    [self.resize(image=__lowerCAmelCase			,       size=__lowerCAmelCase			,       resample=__lowerCAmelCase) for image in images]

					if do_rescale:
							lowerCAmelCase     =    [self.rescale(image=__lowerCAmelCase			,       scale=__lowerCAmelCase) for image in images]

					if do_normalize:
							lowerCAmelCase     =    [self.normalize(image=__lowerCAmelCase			,       mean=__lowerCAmelCase			,       std=__lowerCAmelCase) for image in images]

					lowerCAmelCase     =    [to_channel_dimension_format(__lowerCAmelCase			,       __lowerCAmelCase) for image in images]

					lowerCAmelCase     =    BatchFeature(data={"""pixel_values""": images}			,       tensor_type=__lowerCAmelCase)

					return encoded_outputs




