




import pytest

import datasets


# Import fixture modules as plugins
UpperCAmelCase_		:				Any									=     ["tests.fixtures.files", "tests.fixtures.hub", "tests.fixtures.fsspec"]




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase   ):
				# Mark tests as "unit" by default if not marked as "integration" (or already marked as "unit")
				for item in items:
								if any(marker in item.keywords for marker in ["""integration""", """unit"""]   ):
												continue
								item.add_marker(pytest.mark.unit   )




def 		lowerCAmelCase_   (	lowerCamelCase   ):
				config.addinivalue_line("""markers"""	,     """torchaudio_latest: mark test to run with torchaudio>=0.12"""   )




@pytest.fixture(autouse=__A   )
def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase   ):
				# test_hf_cache_home = tmp_path_factory.mktemp("cache")  # TODO: why a cache dir per test function does not work?
				__magic_name__	:	Tuple								=tmp_path_factory.getbasetemp() / """cache"""
				__magic_name__	:	List[Any]								=test_hf_cache_home / """datasets"""
				__magic_name__	:	List[Any]								=test_hf_cache_home / """metrics"""
				__magic_name__	:	Tuple								=test_hf_cache_home / """modules"""
				monkeypatch.setattr("""datasets.config.HF_DATASETS_CACHE"""	,     str(__A   )   )
				monkeypatch.setattr("""datasets.config.HF_METRICS_CACHE"""	,     str(__A   )   )
				monkeypatch.setattr("""datasets.config.HF_MODULES_CACHE"""	,     str(__A   )   )
				__magic_name__	:	Dict								=test_hf_datasets_cache / """downloads"""
				monkeypatch.setattr("""datasets.config.DOWNLOADED_DATASETS_PATH"""	,     str(__A   )   )
				__magic_name__	:	str								=test_hf_datasets_cache / """downloads""" / """extracted"""
				monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_PATH"""	,     str(__A   )   )




@pytest.fixture(autouse=__A	,     scope="""session"""   )
def 		lowerCAmelCase_   (	):
				datasets.disable_progress_bar()




@pytest.fixture(autouse=__A   )
def 		lowerCAmelCase_   (	lowerCamelCase   ):
				# don't take tests into account when counting downloads
				monkeypatch.setattr("""datasets.config.HF_UPDATE_DOWNLOAD_COUNTS"""	,     __A   )




@pytest.fixture
def 		lowerCAmelCase_   (	lowerCamelCase   ):
				# Required to suppress RemovedIn20Warning when feature(s) are not compatible with SQLAlchemy 2.0
				# To be removed once SQLAlchemy 2.0 supported
				monkeypatch.setattr("""sqlalchemy.util.deprecations.SILENCE_UBER_WARNING"""	,     __A   )










import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin




class 		__A      (			UpperCamelCase__			):
						UpperCamelCase     						=					"""Speech2TextFeatureExtractor"""
						UpperCamelCase     						=					"""Speech2TextTokenizer"""

						def __init__(		self   :Any    , __snake_case   :int    , __snake_case   :Any ):
										'''simple docstring'''

										super().__init__(__snake_case    , __snake_case )
										__magic_name__	:	Optional[int]								=self.feature_extractor
										__magic_name__	:	Any								=False

						def __call__(		self   :Tuple    , *__snake_case   :List[str]    , **__snake_case   :List[str] ):
										'''simple docstring'''

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

										if "raw_speech" in kwargs:
														warnings.warn("""Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.""" )
														__magic_name__	:	Tuple								=kwargs.pop("""raw_speech""" )
										else:
														__magic_name__	:	List[Any]								=kwargs.pop("""audio"""    , __snake_case )
										__magic_name__	:	Union[str, Any]								=kwargs.pop("""sampling_rate"""    , __snake_case )
										__magic_name__	:	Dict								=kwargs.pop("""text"""    , __snake_case )
										if len(__snake_case ) > 0:
														__magic_name__	:	Union[str, Any]								=args[0]
														__magic_name__	:	int								=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:
														__magic_name__	:	List[str]								=self.feature_extractor(__snake_case    , *__snake_case    , sampling_rate=__snake_case    , **__snake_case )
										if text is not None:
														__magic_name__	:	Any								=self.tokenizer(__snake_case    , **__snake_case )

										if text is None:
														return inputs
										elif audio is None:
														return encodings
										else:
														__magic_name__	:	List[str]								=encodings["""input_ids"""]
														return inputs

						def     A__						(		self   :List[Any]    , *__snake_case   :str    , **__snake_case   :List[str] ):
										'''simple docstring'''

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

						def     A__						(		self   :int    , *__snake_case   :int    , **__snake_case   :Optional[int] ):
										'''simple docstring'''

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


						@contextmanager
						def     A__						(		self   :int ):
										'''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.""" )
										__magic_name__	:	int								=True
										__magic_name__	:	List[Any]								=self.tokenizer
										yield
										__magic_name__	:	List[Any]								=self.feature_extractor
										__magic_name__	:	str								=False




