code: 
  
  
  
  
  
  
  import warnings
  from contextlib import contextmanager
  
  from ...processing_utils import ProcessorMixin
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      Optional[Any]     ='AutoFeatureExtractor'
        UpperCamelCase_       :      Tuple     ='Speech2Text2Tokenizer'
        def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Any:
            super().__init__(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Union[str, Any]										=     self.feature_extractor
            UpperCamelCase :int										=     False
        def __call__(       self					,       *SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)       ->   Any:
            # For backward compatibility
            if self._in_target_context_manager:
                return self.current_processor(*SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
  
            if "raw_speech" in kwargs:
                warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'''				)
                UpperCamelCase :Tuple										=     kwargs.pop('''raw_speech'''				)
            else:
                UpperCamelCase :Any										=     kwargs.pop('''audio'''					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Dict										=     kwargs.pop('''sampling_rate'''					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :List[Any]										=     kwargs.pop('''text'''					,       SCREAMING_SNAKE_CASE_				)
            if len(SCREAMING_SNAKE_CASE_				) > 0:
                UpperCamelCase :Optional[int]										=     args[0]
                UpperCamelCase :Optional[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:
                UpperCamelCase :int										=     self.feature_extractor(SCREAMING_SNAKE_CASE_					,       *SCREAMING_SNAKE_CASE_					,       sampling_rate=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
            if text is not None:
                UpperCamelCase :List[Any]										=     self.tokenizer(SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
  
            if text is None:
                return inputs
            elif audio is None:
                return encodings
            else:
                UpperCamelCase :List[str]										=     encodings['''input_ids''']
                return inputs
        def 					UpperCAmelCase		(       self					,       *SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)       ->   Optional[Any]:
            return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self					,       *SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)       ->   Tuple:
            return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
  
  
  
  
        @contextmanager
        def 					UpperCAmelCase		(       self				)       ->   str:
            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 :List[str]										=     True
            UpperCamelCase :List[Any]										=     self.tokenizer
            yield
            UpperCamelCase :Union[str, Any]										=     self.feature_extractor
            UpperCamelCase :List[Any]										=     False
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __snake_case							      =						{
      """configuration_open_llama""": ["""OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenLlamaConfig"""],
  }
  
  try:
   if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						["""LlamaTokenizer"""]
  
  try:
   if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						["""LlamaTokenizerFast"""]
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						[
       """OpenLlamaForCausalLM""",
       """OpenLlamaModel""",
       """OpenLlamaPreTrainedModel""",
       """OpenLlamaForSequenceClassification""",
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig
  
   try:
    if not is_sentencepiece_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from transformers import LlamaTokenizer
  
   try:
    if not is_tokenizers_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from transformers import LlamaTokenizerFast
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_open_llama import (
        OpenLlamaForCausalLM,
        OpenLlamaForSequenceClassification,
        OpenLlamaModel,
        OpenLlamaPreTrainedModel,
    )
  
  
  else:
   import sys
  
   __snake_case							      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
  
  