





'''simple docstring'''






import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin







class 		UpperCAmelCase   (				lowercase_):


		"""simple docstring"""







		lowerCAmelCase_					=				"""MCTCTFeatureExtractor"""
		lowerCAmelCase_					=				"""AutoTokenizer"""


		def __init__(				self    :					int							,	UpperCamelCase__    :					Dict							,	UpperCamelCase__    :					Optional[Any]  )     ->						Optional[int]:
				super().__init__(UpperCamelCase__							,	UpperCamelCase__  )
				_UpperCamelCase       			=self.feature_extractor
				_UpperCamelCase       			=False


		def __call__(				self    :					Tuple							,	*UpperCamelCase__    :					List[Any]							,	**UpperCamelCase__    :					Optional[int]  )     ->						str:
				# For backward compatibility
				if self._in_target_context_manager:
						return self.current_processor(*UpperCamelCase__							,	**UpperCamelCase__  )

				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'''							,	UpperCamelCase__  )
				_UpperCamelCase       			=kwargs.pop('''sampling_rate'''							,	UpperCamelCase__  )
				_UpperCamelCase       			=kwargs.pop('''text'''							,	UpperCamelCase__  )
				if len(UpperCamelCase__  ) > 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(UpperCamelCase__							,	*UpperCamelCase__							,	sampling_rate=UpperCamelCase__							,	**UpperCamelCase__  )
				if text is not None:
						_UpperCamelCase       			=self.tokenizer(UpperCamelCase__							,	**UpperCamelCase__  )

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


		def   UpperCamelCase__      (				self    :					int							,	*UpperCamelCase__    :					int							,	**UpperCamelCase__    :					List[str]  )     ->						int:
				return self.tokenizer.batch_decode(*UpperCamelCase__							,	**UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					Dict							,	*UpperCamelCase__    :					List[Any]							,	**UpperCamelCase__    :					int  )     ->						Tuple:
				# For backward compatibility
				if self._in_target_context_manager:
						return self.current_processor.pad(*UpperCamelCase__							,	**UpperCamelCase__  )

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

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

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


		def   UpperCamelCase__      (				self    :					Optional[Any]							,	*UpperCamelCase__    :					Dict							,	**UpperCamelCase__    :					int  )     ->						List[Any]:
				return self.tokenizer.decode(*UpperCamelCase__							,	**UpperCamelCase__  )




		@contextmanager
		def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Tuple:
				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'''






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCamelCase						: Optional[int]		=   {
    'configuration_xmod': [
        'XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'XmodConfig',
        'XmodOnnxConfig',
    ],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: int		=   [
          'XMOD_PRETRAINED_MODEL_ARCHIVE_LIST',
          'XmodForCausalLM',
          'XmodForMaskedLM',
          'XmodForMultipleChoice',
          'XmodForQuestionAnswering',
          'XmodForSequenceClassification',
          'XmodForTokenClassification',
          'XmodModel',
          'XmodPreTrainedModel',
      ]

if TYPE_CHECKING:
      from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_xmod import (
                XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
                XmodForCausalLM,
                XmodForMaskedLM,
                XmodForMultipleChoice,
                XmodForQuestionAnswering,
                XmodForSequenceClassification,
                XmodForTokenClassification,
                XmodModel,
                XmodPreTrainedModel,
            )

else:
      import sys

      __lowerCamelCase						: Dict		=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






