

"""simple docstring"""


import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a					:Dict    = logging.get_logger(__name__)

a					:Any    = {
    "facebook/wav2vec2-base-960h": "https://huggingface.co/facebook/wav2vec2-base-960h/resolve/main/config.json",
    # See all Wav2Vec2 models at https://huggingface.co/models?filter=wav2vec2
}

class      __a							(__A):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE						:Tuple       = """wav2vec2"""

     def __init__(						self	,    _a=32	,    _a=768	,    _a=12	,    _a=12	,    _a=3_072	,    _a="gelu"	,    _a=0.1	,    _a=0.1	,    _a=0.1	,    _a=0.0	,    _a=0.0	,    _a=0.1	,    _a=0.1	,    _a=0.02	,    _a=1E-5	,    _a="group"	,    _a="gelu"	,    _a=(512, 512, 512, 512, 512, 512, 512)	,    _a=(5, 2, 2, 2, 2, 2, 2)	,    _a=(10, 3, 3, 3, 3, 2, 2)	,    _a=False	,    _a=128	,    _a=16	,    _a=False	,    _a=True	,    _a=0.05	,    _a=10	,    _a=2	,    _a=0.0	,    _a=10	,    _a=0	,    _a=320	,    _a=2	,    _a=0.1	,    _a=100	,    _a=256	,    _a=256	,    _a=0.1	,    _a="sum"	,    _a=False	,    _a=False	,    _a=256	,    _a=(512, 512, 512, 512, 1_500)	,    _a=(5, 3, 3, 1, 1)	,    _a=(1, 2, 3, 1, 1)	,    _a=512	,    _a=0	,    _a=1	,    _a=2	,    _a=False	,    _a=3	,    _a=2	,    _a=3	,    _a=None	,    _a=None	,    **_a	,    )  ->      Tuple:


           """simple docstring"""


           super().__init__(**UpperCamelCase__	,    pad_token_id=UpperCamelCase__	,    bos_token_id=UpperCamelCase__	,    eos_token_id=UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      Dict      		=	hidden_size
           SCREAMING_SNAKE_CASE__   :      Dict      		=	feat_extract_norm
           SCREAMING_SNAKE_CASE__   :      Any      		=	feat_extract_activation
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	conv_bias
           SCREAMING_SNAKE_CASE__   :      int      		=	num_conv_pos_embeddings
           SCREAMING_SNAKE_CASE__   :      str      		=	num_conv_pos_embedding_groups
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	len(self.conv_dim  )
           SCREAMING_SNAKE_CASE__   :      Dict      		=	num_hidden_layers
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	intermediate_size
           SCREAMING_SNAKE_CASE__   :      int      		=	hidden_act
           SCREAMING_SNAKE_CASE__   :      Dict      		=	num_attention_heads
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	hidden_dropout
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	attention_dropout
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	activation_dropout
           SCREAMING_SNAKE_CASE__   :      Dict      		=	feat_proj_dropout
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	final_dropout
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	layerdrop
           SCREAMING_SNAKE_CASE__   :      str      		=	layer_norm_eps
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	initializer_range
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	vocab_size
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	do_stable_layer_norm
           SCREAMING_SNAKE_CASE__   :      str      		=	use_weighted_layer_sum

           if (
               (len(self.conv_stride  ) != self.num_feat_extract_layers)
               or (len(self.conv_kernel  ) != self.num_feat_extract_layers)
               or (len(self.conv_dim  ) != self.num_feat_extract_layers)
           ):
                 raise ValueError(
                     """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="""
                     """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="""
                     f''' {len(self.conv_dim  )}`, `len(config.conv_stride) = {len(self.conv_stride  )}`,'''
                     f''' `len(config.conv_kernel) = {len(self.conv_kernel  )}`.'''  )

           # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
           SCREAMING_SNAKE_CASE__   :      int      		=	apply_spec_augment
           SCREAMING_SNAKE_CASE__   :      int      		=	mask_time_prob
           SCREAMING_SNAKE_CASE__   :      Dict      		=	mask_time_length
           SCREAMING_SNAKE_CASE__   :      Any      		=	mask_time_min_masks
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	mask_feature_prob
           SCREAMING_SNAKE_CASE__   :      int      		=	mask_feature_length
           SCREAMING_SNAKE_CASE__   :      int      		=	mask_feature_min_masks

           # parameters for pretraining with codevector quantized representations
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	num_codevectors_per_group
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	num_codevector_groups
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	contrastive_logits_temperature
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	feat_quantizer_dropout
           SCREAMING_SNAKE_CASE__   :      Dict      		=	num_negatives
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	codevector_dim
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	proj_codevector_dim
           SCREAMING_SNAKE_CASE__   :      Dict      		=	diversity_loss_weight

           # ctc loss
           SCREAMING_SNAKE_CASE__   :      Dict      		=	ctc_loss_reduction
           SCREAMING_SNAKE_CASE__   :      Dict      		=	ctc_zero_infinity

           # adapter
           SCREAMING_SNAKE_CASE__   :      int      		=	add_adapter
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	adapter_kernel_size
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	adapter_stride
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	num_adapter_layers
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	output_hidden_size or hidden_size
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	adapter_attn_dim

           # SequenceClassification-specific parameter. Feel free to ignore for other classes.
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	classifier_proj_size

           # XVector-specific parameters. Feel free to ignore for other classes.
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      str      		=	list(UpperCamelCase__  )
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	xvector_output_dim





     @property
     def 					_a			(						self  )  ->      List[str]:


           """simple docstring"""


           return functools.reduce(operator.mul	,    self.conv_stride	,    1  )









"""simple docstring"""


import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import AlignProcessor, EfficientNetImageProcessor

@require_vision
class      __a							(unittest.TestCase):






     '''simple docstring'''

     def 					_a			(						self  )  ->      int:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	tempfile.mkdtemp()

           SCREAMING_SNAKE_CASE__   :      Dict      		=	[
               """[UNK]""",
               """[CLS]""",
               """[SEP]""",
               """[PAD]""",
               """[MASK]""",
               """want""",
               """##want""",
               """##ed""",
               """wa""",
               """un""",
               """runn""",
               """##ing""",
               """,""",
               """low""",
               """lowest""",
           ]
           SCREAMING_SNAKE_CASE__   :      Dict      		=	os.path.join(self.tmpdirname	,    VOCAB_FILES_NAMES["""vocab_file"""]  )
           with open(self.vocab_file	,    """w"""	,    encoding="""utf-8"""  ) as vocab_writer:
                 vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]  )  )

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	{
               """do_resize""": True,
               """size""": 20,
               """do_center_crop""": True,
               """crop_size""": 18,
               """do_normalize""": True,
               """image_mean""": [0.48_145_466, 0.4_578_275, 0.40_821_073],
               """image_std""": [0.26_862_954, 0.26_130_258, 0.27_577_711],
           }
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	os.path.join(self.tmpdirname	,    _a  )
           with open(self.image_processor_file	,    """w"""	,    encoding="""utf-8"""  ) as fp:
                 json.dump(_a	,    _a  )

     def 					_a			(						self	,    **_a  )  ->      List[Any]:


           """simple docstring"""


           return BertTokenizer.from_pretrained(self.tmpdirname	,    **_a  )

     def 					_a			(						self	,    **_a  )  ->      List[Any]:


           """simple docstring"""


           return BertTokenizerFast.from_pretrained(self.tmpdirname	,    **_a  )

     def 					_a			(						self	,    **_a  )  ->      Any:


           """simple docstring"""


           return EfficientNetImageProcessor.from_pretrained(self.tmpdirname	,    **_a  )

     def 					_a			(						self  )  ->      List[Any]:


           """simple docstring"""


           shutil.rmtree(self.tmpdirname  )

     def 					_a			(						self  )  ->      Optional[int]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Tuple      		=	[np.random.randint(255	,    size=(3, 30, 400)	,    dtype=np.uinta  )]
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	[Image.fromarray(np.moveaxis(_a	,    0	,    -1  )  ) for x in image_inputs]
           return image_inputs

     def 					_a			(						self  )  ->      List[str]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.get_tokenizer()
           SCREAMING_SNAKE_CASE__   :      str      		=	self.get_rust_tokenizer()
           SCREAMING_SNAKE_CASE__   :      str      		=	self.get_image_processor()

           SCREAMING_SNAKE_CASE__   :      Tuple      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )
           processor_slow.save_pretrained(self.tmpdirname  )
           SCREAMING_SNAKE_CASE__   :      str      		=	AlignProcessor.from_pretrained(self.tmpdirname	,    use_fast=_a  )

           SCREAMING_SNAKE_CASE__   :      int      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )
           processor_fast.save_pretrained(self.tmpdirname  )
           SCREAMING_SNAKE_CASE__   :      Any      		=	AlignProcessor.from_pretrained(self.tmpdirname  )

           self.assertEqual(processor_slow.tokenizer.get_vocab()	,    tokenizer_slow.get_vocab()  )
           self.assertEqual(processor_fast.tokenizer.get_vocab()	,    tokenizer_fast.get_vocab()  )
           self.assertEqual(tokenizer_slow.get_vocab()	,    tokenizer_fast.get_vocab()  )
           self.assertIsInstance(processor_slow.tokenizer	,    _a  )
           self.assertIsInstance(processor_fast.tokenizer	,    _a  )

           self.assertEqual(processor_slow.image_processor.to_json_string()	,    image_processor.to_json_string()  )
           self.assertEqual(processor_fast.image_processor.to_json_string()	,    image_processor.to_json_string()  )
           self.assertIsInstance(processor_slow.image_processor	,    _a  )
           self.assertIsInstance(processor_fast.image_processor	,    _a  )

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	AlignProcessor(tokenizer=self.get_tokenizer()	,    image_processor=self.get_image_processor()  )
           processor.save_pretrained(self.tmpdirname  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	self.get_tokenizer(bos_token="""(BOS)"""	,    eos_token="""(EOS)"""  )
           SCREAMING_SNAKE_CASE__   :      Dict      		=	self.get_image_processor(do_normalize=_a	,    padding_value=1.0  )

           SCREAMING_SNAKE_CASE__   :      Dict      		=	AlignProcessor.from_pretrained(
               self.tmpdirname	,    bos_token="""(BOS)"""	,    eos_token="""(EOS)"""	,    do_normalize=_a	,    padding_value=1.0  )

           self.assertEqual(processor.tokenizer.get_vocab()	,    tokenizer_add_kwargs.get_vocab()  )
           self.assertIsInstance(processor.tokenizer	,    _a  )

           self.assertEqual(processor.image_processor.to_json_string()	,    image_processor_add_kwargs.to_json_string()  )
           self.assertIsInstance(processor.image_processor	,    _a  )

     def 					_a			(						self  )  ->      List[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	self.get_image_processor()
           SCREAMING_SNAKE_CASE__   :      str      		=	self.get_tokenizer()

           SCREAMING_SNAKE_CASE__   :      List[str]      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	image_processor(_a	,    return_tensors="""np"""  )
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	processor(images=_a	,    return_tensors="""np"""  )

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

     def 					_a			(						self  )  ->      Any:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      int      		=	self.get_image_processor()
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	self.get_tokenizer()

           SCREAMING_SNAKE_CASE__   :      Any      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	"""lower newer"""

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	processor(text=_a  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	tokenizer(_a	,    padding="""max_length"""	,    max_length=64  )

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

     def 					_a			(						self  )  ->      Optional[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      str      		=	self.get_image_processor()
           SCREAMING_SNAKE_CASE__   :      int      		=	self.get_tokenizer()

           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )

           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	"""lower newer"""
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE__   :      Any      		=	processor(text=_a	,    images=_a  )

           self.assertListEqual(list(inputs.keys()  )	,    ["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""]  )

           # test if it raises when no input is passed
           with pytest.raises(_a  ):
                 processor()

     def 					_a			(						self  )  ->      Any:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Any      		=	self.get_image_processor()
           SCREAMING_SNAKE_CASE__   :      Dict      		=	self.get_tokenizer()

           SCREAMING_SNAKE_CASE__   :      Tuple      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )

           SCREAMING_SNAKE_CASE__   :      List[str]      		=	[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	processor.batch_decode(_a  )
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	tokenizer.batch_decode(_a  )

           self.assertListEqual(_a	,    _a  )





     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[str]      		=	self.get_image_processor()
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.get_tokenizer()

           SCREAMING_SNAKE_CASE__   :      Dict      		=	AlignProcessor(tokenizer=_a	,    image_processor=_a  )

           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	"""lower newer"""
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE__   :      List[str]      		=	processor(text=_a	,    images=_a  )

           self.assertListEqual(list(inputs.keys()  )	,    processor.model_input_names  )




