


"""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

# rely on isort to merge the imports
from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__SCREAMING_SNAKE_CASE					=						{
    """configuration_convnextv2""": [
        """CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """ConvNextV2Config""",
    ]
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __SCREAMING_SNAKE_CASE					=						[
       """CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """ConvNextV2ForImageClassification""",
       """ConvNextV2Model""",
       """ConvNextV2PreTrainedModel""",
       """ConvNextV2Backbone""",
   ]


if TYPE_CHECKING:
   from .configuration_convnextva import (
       CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
       ConvNextVaConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_convnextva import (
          CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST,
          ConvNextVaBackbone,
          ConvNextVaForImageClassification,
          ConvNextVaModel,
          ConvNextVaPreTrainedModel,
      )

else:
   import sys

   __SCREAMING_SNAKE_CASE					=						_LazyModule(__name__, globals()["""__file__"""], _import_structure)




"""simple docstring"""




import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin





class __snake_case		(					_SCREAMING_SNAKE_CASE      ):







   """simple docstring"""




   lowerCAmelCase_				:   str     	=			'AutoFeatureExtractor'
   lowerCAmelCase_				:   List[Any]     	=			'Speech2Text2Tokenizer'




   def __init__(		self							:int				,  UpperCamelCase__							:List[str]				,  UpperCamelCase__							:Union[str, Any]       ):
          super().__init__(UpperCamelCase__				,  UpperCamelCase__       )
          _a          =				self.feature_extractor
          _a          =				False




   def __call__(		self							:List[str]				,  *UpperCamelCase__							:List[str]				,  **UpperCamelCase__							:Dict       ):
          # 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."       )
                 _a          =				kwargs.pop("raw_speech"       )
          else:
                 _a          =				kwargs.pop("audio"				,  UpperCamelCase__       )
          _a          =				kwargs.pop("sampling_rate"				,  UpperCamelCase__       )
          _a          =				kwargs.pop("text"				,  UpperCamelCase__       )
          if len(UpperCamelCase__       ) > 0:
                 _a          =				args[0]
                 _a          =				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:
                 _a          =				self.feature_extractor(UpperCamelCase__				,  *UpperCamelCase__				,  sampling_rate=UpperCamelCase__				,  **UpperCamelCase__       )
          if text is not None:
                 _a          =				self.tokenizer(UpperCamelCase__				,  **UpperCamelCase__       )

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




   def SCREAMING_SNAKE_CASE_      (		self							:Union[str, Any]				,  *UpperCamelCase__							:int				,  **UpperCamelCase__							:Optional[Any]       ):
          return self.tokenizer.batch_decode(*UpperCamelCase__				,  **UpperCamelCase__       )




   def SCREAMING_SNAKE_CASE_      (		self							:Optional[Any]				,  *UpperCamelCase__							:List[Any]				,  **UpperCamelCase__							:List[Any]       ):
          return self.tokenizer.decode(*UpperCamelCase__				,  **UpperCamelCase__       )




   @contextmanager
   def SCREAMING_SNAKE_CASE_      (		self							:Dict       ):
          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."       )
          _a          =				True
          _a          =				self.tokenizer
          yield
          _a          =				self.feature_extractor
          _a          =				False
