



import enum
import os
from hashlib import shaaaa
from typing import Optional

from .. import config
from .logging import get_logger


lowerCAmelCase__		:					str							=get_logger(__name__)

class        UpperCAmelCase_  (       enum.Enum	):

						'''simple docstring'''




						UpperCamelCase__      :			Optional[Any]      =  """all_checks"""
						UpperCamelCase__      :			Dict      =  """basic_checks"""
						UpperCamelCase__      :			Dict      =  """no_checks"""







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







def      __lowercase       (			a__							,       a__							,       a__=None       )    ->			Dict:






							if expected_checksums is None:
														logger.info('Unable to verify checksums.'       )
														return
							if len(set(_lowercase       ) - set(_lowercase       )       ) > 0:
														raise ExpectedMoreDownloadedFiles(str(set(_lowercase       ) - set(_lowercase       )       )       )
							if len(set(_lowercase       ) - set(_lowercase       )       ) > 0:
														raise UnexpectedDownloadedFile(str(set(_lowercase       ) - set(_lowercase       )       )       )
							__SCREAMING_SNAKE_CASE									= [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
							__SCREAMING_SNAKE_CASE									= " for " + verification_name if verification_name is not None else ""
							if len(_lowercase       ) > 0:
														raise NonMatchingChecksumError(
														    f"""Checksums didn't match{for_verification_name}:\n"""
														    f"""{bad_urls}\n"""
														    'Set `verification_mode=\'no_checks\'` to skip checksums verification and ignore this error'       )
							logger.info('All the checksums matched successfully' + for_verification_name       )

class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







class        UpperCAmelCase_  (       a__	):

						'''simple docstring'''




						pass







def      __lowercase       (			a__							,       a__       )    ->			Dict:






							if expected_splits is None:
														logger.info('Unable to verify splits sizes.'       )
														return
							if len(set(_lowercase       ) - set(_lowercase       )       ) > 0:
														raise ExpectedMoreSplits(str(set(_lowercase       ) - set(_lowercase       )       )       )
							if len(set(_lowercase       ) - set(_lowercase       )       ) > 0:
														raise UnexpectedSplits(str(set(_lowercase       ) - set(_lowercase       )       )       )
							__SCREAMING_SNAKE_CASE									= [
							    {"expected": expected_splits[name], "recorded": recorded_splits[name]}
							    for name in expected_splits
							    if expected_splits[name].num_examples != recorded_splits[name].num_examples
							]
							if len(_lowercase       ) > 0:
														raise NonMatchingSplitsSizesError(str(_lowercase       )       )
							logger.info('All the splits matched successfully.'       )






def      __lowercase       (			a__							,       a__ = True       )    ->			dict:






							if record_checksum:
														__SCREAMING_SNAKE_CASE									= shaaaa()
														with open(_lowercase							,       'rb'       ) as f:
																					for chunk in iter(lambda: f.read(1 << 20       )							,       b''       ):
																												m.update(_lowercase       )
																					__SCREAMING_SNAKE_CASE									= m.hexdigest()
							else:
														__SCREAMING_SNAKE_CASE									= None
							return {"num_bytes": os.path.getsize(_lowercase       ), "checksum": checksum}






def      __lowercase       (			a__       )    ->			Any:






							if dataset_size and config.IN_MEMORY_MAX_SIZE:
														return dataset_size < config.IN_MEMORY_MAX_SIZE
							else:
														return False










import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer

class        UpperCAmelCase_  (       UpperCamelCase_	):

						'''simple docstring'''




						UpperCamelCase__      :			Union[str, Any]      =  '''Wav2Vec2FeatureExtractor'''
						UpperCamelCase__      :			Union[str, Any]      =  '''AutoTokenizer'''






						def __init__(   self				,							_A				,							_A		):







													'''simple docstring'''

													super().__init__(_A				,							_A		)
													__SCREAMING_SNAKE_CASE									= self.feature_extractor
													__SCREAMING_SNAKE_CASE									= False






						@classmethod
						def 	_A     (   cls				,							_A				,							**_A		):







													'''simple docstring'''

													try:
																				return super().from_pretrained(_A				,							**_A		)
													except OSError:
																				warnings.warn(
																				    f"""Loading a tokenizer inside {cls.__name__} from a config that does not"""
																				    ' include a `tokenizer_class` attribute is deprecated and will be '
																				    'removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`'
																				    ' attribute to either your `config.json` or `tokenizer_config.json` '
																				    'file to suppress this warning: '				,							_A				,							)

																				__SCREAMING_SNAKE_CASE									= WavaVecaFeatureExtractor.from_pretrained(_A				,							**_A		)
																				__SCREAMING_SNAKE_CASE									= WavaVecaCTCTokenizer.from_pretrained(_A				,							**_A		)

																				return cls(feature_extractor=_A				,							tokenizer=_A		)






						def __call__(   self				,							*_A				,							**_A		):







													'''simple docstring'''

													if self._in_target_context_manager:
																				return self.current_processor(*_A				,							**_A		)

													if "raw_speech" in kwargs:
																				warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'		)
																				__SCREAMING_SNAKE_CASE									= kwargs.pop('raw_speech'		)
													else:
																				__SCREAMING_SNAKE_CASE									= kwargs.pop('audio'				,							_A		)
													__SCREAMING_SNAKE_CASE									= kwargs.pop('sampling_rate'				,							_A		)
													__SCREAMING_SNAKE_CASE									= kwargs.pop('text'				,							_A		)
													if len(_A		) > 0:
																				__SCREAMING_SNAKE_CASE									= args[0]
																				__SCREAMING_SNAKE_CASE									= args[1:]

													if audio is None and text is None:
																				raise ValueError('You need to specify either an `audio` or `text` input to process.'		)

													if audio is not None:
																				__SCREAMING_SNAKE_CASE									= self.feature_extractor(_A				,							*_A				,							sampling_rate=_A				,							**_A		)
													if text is not None:
																				__SCREAMING_SNAKE_CASE									= self.tokenizer(_A				,							**_A		)

													if text is None:
																				return inputs
													elif audio is None:
																				return encodings
													else:
																				__SCREAMING_SNAKE_CASE									= encodings['input_ids']
																				return inputs






						def 	_A     (   self				,							*_A				,							**_A		):







													'''simple docstring'''

													if self._in_target_context_manager:
																				return self.current_processor.pad(*_A				,							**_A		)

													__SCREAMING_SNAKE_CASE									= kwargs.pop('input_features'				,							_A		)
													__SCREAMING_SNAKE_CASE									= kwargs.pop('labels'				,							_A		)
													if len(_A		) > 0:
																				__SCREAMING_SNAKE_CASE									= args[0]
																				__SCREAMING_SNAKE_CASE									= args[1:]

													if input_features is not None:
																				__SCREAMING_SNAKE_CASE									= self.feature_extractor.pad(_A				,							*_A				,							**_A		)
													if labels is not None:
																				__SCREAMING_SNAKE_CASE									= self.tokenizer.pad(_A				,							**_A		)

													if labels is None:
																				return input_features
													elif input_features is None:
																				return labels
													else:
																				__SCREAMING_SNAKE_CASE									= labels['input_ids']
																				return input_features






						def 	_A     (   self				,							*_A				,							**_A		):







													'''simple docstring'''

													return self.tokenizer.batch_decode(*_A				,							**_A		)






						def 	_A     (   self				,							*_A				,							**_A		):







													'''simple docstring'''

													return self.tokenizer.decode(*_A				,							**_A		)






						@contextmanager
						def 	_A     (   self		):







													'''simple docstring'''

													warnings.warn(
													    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
													    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
													    'your audio inputs, or in a separate call.'		)
													__SCREAMING_SNAKE_CASE									= True
													__SCREAMING_SNAKE_CASE									= self.tokenizer
													yield
													__SCREAMING_SNAKE_CASE									= self.feature_extractor
													__SCREAMING_SNAKE_CASE									= False






