
'''simple docstring'''
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin


class        SCREAMING_SNAKE_CASE__	(			snake_case_):
				lowerCAmelCase_			       =				"""AutoFeatureExtractor"""
				lowerCAmelCase_			       =				"""Speech2Text2Tokenizer"""







				def __init__(    self		,							A_		,							A_			)->						Dict:







											'''simple docstring'''






											super().__init__(A_		,							A_			)
											UpperCamelCase					       =			self.feature_extractor
											UpperCamelCase					       =			False







				def __call__(    self		,							*A_		,							**A_			)->						Optional[int]:







											'''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.'			)
																		UpperCamelCase					       =			kwargs.pop('raw_speech'			)
											else:
																		UpperCamelCase					       =			kwargs.pop('audio'		,							A_			)
											UpperCamelCase					       =			kwargs.pop('sampling_rate'		,							A_			)
											UpperCamelCase					       =			kwargs.pop('text'		,							A_			)
											if len(A_			) > 0:
																		UpperCamelCase					       =			args[0]
																		UpperCamelCase					       =			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:
																		UpperCamelCase					       =			self.feature_extractor(A_		,							*A_		,							sampling_rate=A_		,							**A_			)
											if text is not None:
																		UpperCamelCase					       =			self.tokenizer(A_		,							**A_			)

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







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







											'''simple docstring'''






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







				def 		UpperCAmelCase_  (    self		,							*A_		,							**A_			)->						Optional[int]:







											'''simple docstring'''






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







				@contextmanager
				def 		UpperCAmelCase_  (    self			)->						Dict:







											'''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.'			)
											UpperCamelCase					       =			True
											UpperCamelCase					       =			self.tokenizer
											yield
											UpperCamelCase					       =			self.feature_extractor
											UpperCamelCase					       =			False






'''simple docstring'''
import random
from typing import List, Optional, Union

import numpy as np
import torch

from ..state import AcceleratorState
from .constants import CUDA_DISTRIBUTED_TYPES
from .dataclasses import DistributedType, RNGType
from .imports import is_npu_available, is_tpu_available, is_xpu_available


if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm







def 						A_(			A		:						int						,			A		:						bool = False):
							if device_specific:
														seed += AcceleratorState().process_index
							random.seed(A)
							np.random.seed(A)
							torch.manual_seed(A)
							if is_xpu_available():
														torch.xpu.manual_seed_all(A)
							elif is_npu_available():
														torch.npu.manual_seed_all(A)
							else:
														torch.cuda.manual_seed_all(A)
							# ^^ safe to call this function even if cuda is not available
							if is_tpu_available():
														xm.set_rng_state(A)







def 						A_(			A		:						Optional[RNGType] = None						,			A		:						Optional[torch.Generator] = None):
							# Get the proper rng state
							if rng_type == RNGType.TORCH:
														UpperCamelCase					       =			torch.get_rng_state()
							elif rng_type == RNGType.CUDA:
														UpperCamelCase					       =			torch.cuda.get_rng_state()
							elif rng_type == RNGType.XLA:
														assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
														UpperCamelCase					       =			torch.tensor(xm.get_rng_state())
							elif rng_type == RNGType.NPU:
														assert is_npu_available(), "Can't synchronize NPU seeds on an environment without NPUs."
														UpperCamelCase					       =			torch.npu.get_rng_state()
							elif rng_type == RNGType.XPU:
														assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
														UpperCamelCase					       =			torch.xpu.get_rng_state()
							elif rng_type == RNGType.GENERATOR:
														assert generator is not None, "Need a generator to synchronize its seed."
														UpperCamelCase					       =			generator.get_state()

							# Broadcast the rng state from device 0 to other devices
							UpperCamelCase					       =			AcceleratorState()
							if state.distributed_type == DistributedType.TPU:
														UpperCamelCase					       =			rng_state.to(xm.xla_device())
														xm.collective_broadcast([rng_state])
														xm.mark_step()
														UpperCamelCase					       =			rng_state.cpu()
							elif (
							    state.distributed_type in CUDA_DISTRIBUTED_TYPES
							    or state.distributed_type == DistributedType.MULTI_NPU
							    or state.distributed_type == DistributedType.MULTI_XPU
							):
														UpperCamelCase					       =			rng_state.to(state.device)
														torch.distributed.broadcast(A						,			0)
														UpperCamelCase					       =			rng_state.cpu()
							elif state.distributed_type == DistributedType.MULTI_CPU:
														torch.distributed.broadcast(A						,			0)

							# Set the broadcast rng state
							if rng_type == RNGType.TORCH:
														torch.set_rng_state(A)
							elif rng_type == RNGType.CUDA:
														torch.cuda.set_rng_state(A)
							elif rng_type == RNGType.NPU:
														torch.npu.set_rng_state(A)
							elif rng_type == RNGType.XPU:
														torch.xpu.set_rng_state(A)
							elif rng_type == RNGType.XLA:
														xm.set_rng_state(rng_state.item())
							elif rng_type == RNGType.GENERATOR:
														generator.set_state(A)







def 						A_(			A		:						List[Union[str, RNGType]]						,			A		:						Optional[torch.Generator] = None):
							for rng_type in rng_types:
														synchronize_rng_state(RNGType(A)						,			generator=A)




