
"""simple docstring"""





import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
				from .features import FeatureType


_a							,							_a							,							_a														=		False, False, False






@dataclass
class    _UpperCAmelCase:
		lowercase__      =				None
		lowercase__      =				True
		lowercase__      =				True
		lowercase__      =				None
		# Automatically constructed
		lowercase__      =				"dict"
		lowercase__      =				pa.struct({'bytes': pa.binary(), 'path': pa.string()}     )
		lowercase__      =				field(default='Audio'				,					init=lowerCamelCase				,					repr=lowerCamelCase     )



		def __call__( self)	->	int:






							'''simple docstring'''
							return self.pa_type



		def 						UpperCAmelCase							( self    ,		__a)	->	dict:






							'''simple docstring'''
							try:
												import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
							except ImportError as err:
												raise ImportError('''To support encoding audio data, please install \'soundfile\'.''') from err
							if isinstance(__a    ,		__a):
												return {"bytes": None, "path": value}
							elif isinstance(__a    ,		__a):
												return {"bytes": value, "path": None}
							elif "array" in value:
												# convert the audio array to wav bytes
												_UpperCamelCase										=  BytesIO()
												sf.write(__a    ,		value['''array''']    ,		value['''sampling_rate''']    ,		format='''wav''')
												return {"bytes": buffer.getvalue(), "path": None}
							elif value.get('''path''') is not None and os.path.isfile(value['''path''']):
												# we set "bytes": None to not duplicate the data if they're already available locally
												if value["path"].endswith('''pcm'''):
																	# "PCM" only has raw audio bytes
																	if value.get('''sampling_rate''') is None:
																						# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
																						raise KeyError('''To use PCM files, please specify a \'sampling_rate\' in Audio object''')
																	if value.get('''bytes'''):
																						# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
																						_UpperCamelCase										=  np.frombuffer(value['''bytes''']    ,		dtype=np.intaa).astype(np.floataa) / 3_27_67
																	else:
																						_UpperCamelCase										=  np.memmap(value['''path''']    ,		dtype='''h'''    ,		mode='''r''').astype(np.floataa) / 3_27_67

																	_UpperCamelCase										=  BytesIO(bytes())
																	sf.write(__a    ,		__a    ,		value['''sampling_rate''']    ,		format='''wav''')
																	return {"bytes": buffer.getvalue(), "path": None}
												else:
																	return {"bytes": None, "path": value.get('''path''')}
							elif value.get('''bytes''') is not None or value.get('''path''') is not None:
												# store the audio bytes, and path is used to infer the audio format using the file extension
												return {"bytes": value.get('''bytes'''), "path": value.get('''path''')}
							else:
												raise ValueError(
												    F'''An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''')



		def 						UpperCAmelCase							( self    ,		__a    ,		__a = None)	->	dict:






							'''simple docstring'''
							if not self.decode:
												raise RuntimeError('''Decoding is disabled for this feature. Please use Audio(decode=True) instead.''')

							_UpperCamelCase			,  _UpperCamelCase										=  (value['''path'''], BytesIO(value['''bytes'''])) if value['''bytes'''] is not None else (value['''path'''], None)
							if path is None and file is None:
												raise ValueError(F'''An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.''')

							try:
												import librosa
												import soundfile as sf
							except ImportError as err:
												raise ImportError('''To support decoding audio files, please install \'librosa\' and \'soundfile\'.''') from err

							_UpperCamelCase										=  xsplitext(__a)[1][1:].lower() if path is not None else None
							if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
												raise RuntimeError(
												    '''Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, '''
												    '''You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ''')
							elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
												raise RuntimeError(
												    '''Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, '''
												    '''You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ''')

							if file is None:
												_UpperCamelCase										=  token_per_repo_id or {}
												_UpperCamelCase										=  path.split('''::''')[-1]
												try:
																	_UpperCamelCase										=  string_to_dict(__a    ,		config.HUB_DATASETS_URL)['''repo_id''']
																	_UpperCamelCase										=  token_per_repo_id[repo_id]
												except (ValueError, KeyError):
																	_UpperCamelCase										=  None

												with xopen(__a    ,		'''rb'''    ,		use_auth_token=__a) as f:
																	_UpperCamelCase			,  _UpperCamelCase										=  sf.read(__a)

							else:
												_UpperCamelCase			,  _UpperCamelCase										=  sf.read(__a)

							_UpperCamelCase										=  array.T
							if self.mono:
												_UpperCamelCase										=  librosa.to_mono(__a)
							if self.sampling_rate and self.sampling_rate != sampling_rate:
												_UpperCamelCase										=  librosa.resample(__a    ,		orig_sr=__a    ,		target_sr=self.sampling_rate)
												_UpperCamelCase										=  self.sampling_rate

							return {"path": path, "array": array, "sampling_rate": sampling_rate}



		def 						UpperCAmelCase							( self)	->	Union["FeatureType", Dict[str, "FeatureType"]]:






							'''simple docstring'''
							from .features import Value

							if self.decode:
												raise ValueError('''Cannot flatten a decoded Audio feature.''')
							return {
							    "bytes": Value('''binary'''),
							    "path": Value('''string'''),
							}



		def 						UpperCAmelCase							( self    ,		__a)	->	pa.StructArray:






							'''simple docstring'''
							if pa.types.is_string(storage.type):
												_UpperCamelCase										=  pa.array([None] * len(__a)    ,		type=pa.binary())
												_UpperCamelCase										=  pa.StructArray.from_arrays([bytes_array, storage]    ,		['''bytes''', '''path''']    ,		mask=storage.is_null())
							elif pa.types.is_binary(storage.type):
												_UpperCamelCase										=  pa.array([None] * len(__a)    ,		type=pa.string())
												_UpperCamelCase										=  pa.StructArray.from_arrays([storage, path_array]    ,		['''bytes''', '''path''']    ,		mask=storage.is_null())
							elif pa.types.is_struct(storage.type) and storage.type.get_all_field_indices('''array'''):
												_UpperCamelCase										=  pa.array([Audio().encode_example(__a) if x is not None else None for x in storage.to_pylist()])
							elif pa.types.is_struct(storage.type):
												if storage.type.get_field_index('''bytes''') >= 0:
																	_UpperCamelCase										=  storage.field('''bytes''')
												else:
																	_UpperCamelCase										=  pa.array([None] * len(__a)    ,		type=pa.binary())
												if storage.type.get_field_index('''path''') >= 0:
																	_UpperCamelCase										=  storage.field('''path''')
												else:
																	_UpperCamelCase										=  pa.array([None] * len(__a)    ,		type=pa.string())
												_UpperCamelCase										=  pa.StructArray.from_arrays([bytes_array, path_array]    ,		['''bytes''', '''path''']    ,		mask=storage.is_null())
							return array_cast(__a    ,		self.pa_type)




		def 						UpperCAmelCase							( self    ,		__a)	->	pa.StructArray:






							'''simple docstring'''

							@no_op_if_value_is_null
							def path_to_bytes(__a):
												with xopen(__a    ,		'''rb''') as f:
																	_UpperCamelCase										=  f.read()
												return bytes_

							_UpperCamelCase										=  pa.array(
							    [
							        (path_to_bytes(x['''path''']) if x['''bytes'''] is None else x['''bytes''']) if x is not None else None
							        for x in storage.to_pylist()
							    ]    ,		type=pa.binary()    ,		)
							_UpperCamelCase										=  pa.array(
							    [os.path.basename(__a) if path is not None else None for path in storage.field('''path''').to_pylist()]    ,		type=pa.string()    ,		)
							_UpperCamelCase										=  pa.StructArray.from_arrays([bytes_array, path_array]    ,		['''bytes''', '''path''']    ,		mask=bytes_array.is_null())
							return array_cast(__a    ,		self.pa_type)








"""simple docstring"""





import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    MODEL_FOR_PRETRAINING_MAPPING,
				    AlbertForMaskedLM,
				    AlbertForMultipleChoice,
				    AlbertForPreTraining,
				    AlbertForQuestionAnswering,
				    AlbertForSequenceClassification,
				    AlbertForTokenClassification,
				    AlbertModel,
				)
				from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST






class    _UpperCAmelCase:



		def __init__( self    ,		__a    ,		__a=13    ,		__a=7    ,		__a=True    ,		__a=True    ,		__a=True    ,		__a=True    ,		__a=99    ,		__a=16    ,		__a=36    ,		__a=6    ,		__a=6    ,		__a=6    ,		__a=37    ,		__a="gelu"    ,		__a=0.1    ,		__a=0.1    ,		__a=5_12    ,		__a=16    ,		__a=2    ,		__a=0.02    ,		__a=3    ,		__a=4    ,		__a=None    ,		)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  parent
							_UpperCamelCase										=  batch_size
							_UpperCamelCase										=  seq_length
							_UpperCamelCase										=  is_training
							_UpperCamelCase										=  use_input_mask
							_UpperCamelCase										=  use_token_type_ids
							_UpperCamelCase										=  use_labels
							_UpperCamelCase										=  vocab_size
							_UpperCamelCase										=  embedding_size
							_UpperCamelCase										=  hidden_size
							_UpperCamelCase										=  num_hidden_layers
							_UpperCamelCase										=  num_hidden_groups
							_UpperCamelCase										=  num_attention_heads
							_UpperCamelCase										=  intermediate_size
							_UpperCamelCase										=  hidden_act
							_UpperCamelCase										=  hidden_dropout_prob
							_UpperCamelCase										=  attention_probs_dropout_prob
							_UpperCamelCase										=  max_position_embeddings
							_UpperCamelCase										=  type_vocab_size
							_UpperCamelCase										=  type_sequence_label_size
							_UpperCamelCase										=  initializer_range
							_UpperCamelCase										=  num_labels
							_UpperCamelCase										=  num_choices
							_UpperCamelCase										=  scope



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






							'''simple docstring'''
							_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.vocab_size)

							_UpperCamelCase										=  None
							if self.use_input_mask:
												_UpperCamelCase										=  random_attention_mask([self.batch_size, self.seq_length])

							_UpperCamelCase										=  None
							if self.use_token_type_ids:
												_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.type_vocab_size)

							_UpperCamelCase										=  None
							_UpperCamelCase										=  None
							_UpperCamelCase										=  None
							if self.use_labels:
												_UpperCamelCase										=  ids_tensor([self.batch_size]    ,		self.type_sequence_label_size)
												_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.num_labels)
												_UpperCamelCase										=  ids_tensor([self.batch_size]    ,		self.num_choices)

							_UpperCamelCase										=  self.get_config()

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



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






							'''simple docstring'''
							return AlbertConfig(
							    vocab_size=self.vocab_size    ,		hidden_size=self.hidden_size    ,		num_hidden_layers=self.num_hidden_layers    ,		num_attention_heads=self.num_attention_heads    ,		intermediate_size=self.intermediate_size    ,		hidden_act=self.hidden_act    ,		hidden_dropout_prob=self.hidden_dropout_prob    ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,		max_position_embeddings=self.max_position_embeddings    ,		type_vocab_size=self.type_vocab_size    ,		initializer_range=self.initializer_range    ,		num_hidden_groups=self.num_hidden_groups    ,		)



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		token_type_ids=__a)
							_UpperCamelCase										=  model(__a    ,		token_type_ids=__a)
							_UpperCamelCase										=  model(__a)
							self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.seq_length, self.hidden_size))
							self.parent.assertEqual(result.pooler_output.shape    ,		(self.batch_size, self.hidden_size))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertForPreTraining(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(
							    __a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a    ,		sentence_order_label=__a    ,		)
							self.parent.assertEqual(result.prediction_logits.shape    ,		(self.batch_size, self.seq_length, self.vocab_size))
							self.parent.assertEqual(result.sop_logits.shape    ,		(self.batch_size, config.num_labels))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertForMaskedLM(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.vocab_size))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertForQuestionAnswering(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(
							    __a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		start_positions=__a    ,		end_positions=__a    ,		)
							self.parent.assertEqual(result.start_logits.shape    ,		(self.batch_size, self.seq_length))
							self.parent.assertEqual(result.end_logits.shape    ,		(self.batch_size, self.seq_length))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  self.num_labels
							_UpperCamelCase										=  AlbertForSequenceClassification(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_labels))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.num_labels
							_UpperCamelCase										=  AlbertForTokenClassification(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.num_labels))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.num_choices
							_UpperCamelCase										=  AlbertForMultipleChoice(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  input_ids.unsqueeze(1).expand(-1    ,		self.num_choices    ,		-1).contiguous()
							_UpperCamelCase										=  token_type_ids.unsqueeze(1).expand(-1    ,		self.num_choices    ,		-1).contiguous()
							_UpperCamelCase										=  input_mask.unsqueeze(1).expand(-1    ,		self.num_choices    ,		-1).contiguous()
							_UpperCamelCase										=  model(
							    __a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a    ,		)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_choices))




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






							'''simple docstring'''
							_UpperCamelCase										=  self.prepare_config_and_inputs()
							(
							    (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  
							)										=  config_and_inputs
							_UpperCamelCase										=  {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
							return config, inputs_dict






@require_torch
class    _UpperCAmelCase(   lowerCamelCase				,					lowerCamelCase				,					unittest.TestCase     ):
		lowercase__      =				(
		    (
		        AlbertModel,
		        AlbertForPreTraining,
		        AlbertForMaskedLM,
		        AlbertForMultipleChoice,
		        AlbertForSequenceClassification,
		        AlbertForTokenClassification,
		        AlbertForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		lowercase__      =				(
		    {
		        'feature-extraction': AlbertModel,
		        'fill-mask': AlbertForMaskedLM,
		        'question-answering': AlbertForQuestionAnswering,
		        'text-classification': AlbertForSequenceClassification,
		        'token-classification': AlbertForTokenClassification,
		        'zero-shot': AlbertForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		lowercase__      =				True



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a=False)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  super()._prepare_for_class(__a    ,		__a    ,		return_labels=__a)

							if return_labels:
												if model_class in get_values(__a):
																	_UpperCamelCase										=  torch.zeros(
																	    (self.model_tester.batch_size, self.model_tester.seq_length)    ,		dtype=torch.long    ,		device=__a)
																	_UpperCamelCase										=  torch.zeros(
																	    self.model_tester.batch_size    ,		dtype=torch.long    ,		device=__a)
							return inputs_dict



		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertModelTester(self)
							_UpperCamelCase										=  ConfigTester(self    ,		config_class=__a    ,		hidden_size=37)



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






							'''simple docstring'''
							self.config_tester.run_common_tests()



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






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*__a)



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






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__a)



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__a)



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__a)



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






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__a)



		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
												_UpperCamelCase										=  type
												self.model_tester.create_and_check_model(*__a)




		@slow
		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase										=  AlbertModel.from_pretrained(__a)
												self.assertIsNotNone(__a)






@require_torch
class    _UpperCAmelCase(   unittest.TestCase     ):



		@slow
		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  AlbertModel.from_pretrained('''albert-base-v2''')
							_UpperCamelCase										=  torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]])
							_UpperCamelCase										=  torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
							with torch.no_grad():
												_UpperCamelCase										=  model(__a    ,		attention_mask=__a)[0]
							_UpperCamelCase										=  torch.Size((1, 11, 7_68))
							self.assertEqual(output.shape    ,		__a)
							_UpperCamelCase										=  torch.tensor(
							    [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]])

							self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,		__a    ,		atol=1e-4))






