





"""simple docstring"""




# Copyright 2023 The HuggingFace Inc. 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.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
		import torch


a						: Dict     	=			logging.get_logger(__name__)


@dataclass
class        __UpperCamelCase				:






							def __init__(   self      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=6.0      ,					lowerCAmelCase__=None      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=None      ,					lowerCAmelCase__="fp4"      ,					lowerCAmelCase__=False      ,					**lowerCAmelCase__      ,					)	-> Any:
								a      :		Tuple	=				load_in_abit
								a      :		Optional[int]	=				load_in_abit
								a      :		List[str]	=				llm_inta_threshold
								a      :		List[Any]	=				llm_inta_skip_modules
								a      :		Union[str, Any]	=				llm_inta_enable_fpaa_cpu_offload
								a      :		Optional[int]	=				llm_inta_has_fpaa_weight
								a      :		Optional[Any]	=				bnb_abit_quant_type
								a      :		Union[str, Any]	=				bnb_abit_use_double_quant

								if bnb_abit_compute_dtype is None:
									a      :		str	=				torch.floataa
								elif isinstance(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									a      :		Optional[int]	=				getattr(lowerCAmelCase__      ,					lowerCAmelCase__      )
								elif isinstance(lowerCAmelCase__      ,					torch.dtype      ):
									a      :		List[Any]	=				bnb_abit_compute_dtype
								else:
									raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype"      )

								self.post_init()






							def     __a   (   self      )	-> int:
								if not isinstance(self.llm_inta_threshold      ,					lowerCAmelCase__      ):
									raise ValueError("llm_int8_threshold must be a float"      )

								if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules      ,					lowerCAmelCase__      ):
									raise ValueError("llm_int8_skip_modules must be a list of strings"      )
								if not isinstance(self.llm_inta_enable_fpaa_cpu_offload      ,					lowerCAmelCase__      ):
									raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"      )

								if not isinstance(self.llm_inta_has_fpaa_weight      ,					lowerCAmelCase__      ):
									raise ValueError("llm_int8_has_fp16_weight must be a boolean"      )

								if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype      ,					torch.dtype      ):
									raise ValueError("bnb_4bit_compute_dtype must be torch.dtype"      )

								if not isinstance(self.bnb_abit_quant_type      ,					lowerCAmelCase__      ):
									raise ValueError("bnb_4bit_quant_type must be a string"      )

								if not isinstance(self.bnb_abit_use_double_quant      ,					lowerCAmelCase__      ):
									raise ValueError("bnb_4bit_use_double_quant must be a boolean"      )

								if self.load_in_abit and not version.parse(importlib.metadata.version("bitsandbytes"      )      ) >= version.parse(
								    "0.39.0"      ):
									raise ValueError(
									    "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version"      )






							def     __a   (   self      )	-> Tuple:
								return self.load_in_abit or self.load_in_abit






							def     __a   (   self      )	-> Any:
								if self.load_in_abit:
									return "llm_int8"
								elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
									return "fp4"
								elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
									return "nf4"
								else:
									return None






							@classmethod
							def     __a   (   cls      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					**lowerCAmelCase__      )	-> str:
								a      :		List[Any]	=				cls(**lowerCAmelCase__      )

								a      :		Optional[int]	=				[]
								for key, value in kwargs.items():
									if hasattr(lowerCAmelCase__      ,					lowerCAmelCase__      ):
										setattr(lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )
										to_remove.append(lowerCAmelCase__      )
								for key in to_remove:
									kwargs.pop(lowerCAmelCase__      ,					lowerCAmelCase__      )

								if return_unused_kwargs:
									return config, kwargs
								else:
									return config






							def     __a   (   self      ,					lowerCAmelCase__      )	-> int:
								with open(lowerCAmelCase__      ,					"w"      ,					encoding="utf-8"      ) as writer:
									a      :		List[str]	=				self.to_dict()
									a      :		Tuple	=				json.dumps(lowerCAmelCase__      ,					indent=2      ,					sort_keys=lowerCAmelCase__      ) + "\n"

									writer.write(lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict[str, Any]:
								a      :		Tuple	=				copy.deepcopy(self.__dict__      )
								a      :		Dict	=				str(output["bnb_4bit_compute_dtype"]      ).split("."      )[1]

								return output






							def __repr__(   self      )	-> List[str]:
								return f"""{self.__class__.__name__} {self.to_json_string()}"""






							def     __a   (   self      ,					lowerCAmelCase__ = True      )	-> str:
								if use_diff is True:
									a      :		List[Any]	=				self.to_diff_dict()
								else:
									a      :		Dict	=				self.to_dict()
								return json.dumps(lowerCAmelCase__      ,					indent=2      ,					sort_keys=lowerCAmelCase__      ) + "\n"






							def     __a   (   self      )	-> Dict[str, Any]:
								a      :		str	=				self.to_dict()

								# get the default config dict
								a      :		Tuple	=				BitsAndBytesConfig().to_dict()

								a      :		List[Any]	=				{}

								# only serialize values that differ from the default config
								for key, value in config_dict.items():
									if value != default_config_dict[key]:
										a      :		Any	=				value

								return serializable_config_dict







'''simple docstring'''





import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin






class __A			(  A						):



 '''simple docstring'''







 __lowerCamelCase    :       Optional[Any]          =       'MCTCTFeatureExtractor'
 __lowerCamelCase    :       Optional[Any]          =       'AutoTokenizer'



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


      """simple docstring"""



      super().__init__(A ,   A       )
      _a      =  self.feature_extractor
      _a      =  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.'''       )
           _a      =  kwargs.pop('''raw_speech'''       )
      else:
           _a      =  kwargs.pop('''audio''' ,   A       )
      _a      =  kwargs.pop('''sampling_rate''' ,   A       )
      _a      =  kwargs.pop('''text''' ,   A       )
      if len(A       ) > 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(A ,   *A ,   sampling_rate=A ,   **A       )
      if text is not None:
           _a      =  self.tokenizer(A ,   **A       )

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



 def 					a__  (self ,   *A ,   **A       )    ->     int:


      """simple docstring"""



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



 def 					a__  (self ,   *A ,   **A       )    ->     Tuple:


      """simple docstring"""



      if self._in_target_context_manager:
           return self.current_processor.pad(*A ,   **A       )

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

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

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



 def 					a__  (self ,   *A ,   **A       )    ->     List[str]:


      """simple docstring"""



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



 @contextmanager
 def 					a__  (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.'''       )
      _a      =  True
      _a      =  self.tokenizer
      yield
      _a      =  self.feature_extractor
      _a      =  False



