
'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 import os as original_os
 from os import path as original_path
 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join

 lowerCAmelCase__     :   int     		=	"__test_patch_submodule_mock__"
 with patch_submodule(_test_patching      ,			"os.path.join"      ,			lowerCamelCase_			):
  # Every way to access os.path.join must be patched, and the rest must stay untouched

  # check os.path.join
  assert isinstance(_test_patching.os      ,			_PatchedModuleObj			)
  assert isinstance(_test_patching.os.path      ,			_PatchedModuleObj			)
  assert _test_patching.os.path.join is mock

  # check path.join
  assert isinstance(_test_patching.path      ,			_PatchedModuleObj			)
  assert _test_patching.path.join is mock

  # check join
  assert _test_patching.join is mock

  # check that the other attributes are untouched
  assert _test_patching.os.rename is original_rename
  assert _test_patching.path.dirname is original_dirname
  assert _test_patching.os.path.dirname is original_dirname

  # Even renamed modules or objects must be patched

  # check renamed_os.path.join
  assert isinstance(_test_patching.renamed_os      ,			_PatchedModuleObj			)
  assert isinstance(_test_patching.renamed_os.path      ,			_PatchedModuleObj			)
  assert _test_patching.renamed_os.path.join is mock

  # check renamed_path.join
  assert isinstance(_test_patching.renamed_path      ,			_PatchedModuleObj			)
  assert _test_patching.renamed_path.join is mock

  # check renamed_join
  assert _test_patching.renamed_join is mock

  # check that the other attributes are untouched
  assert _test_patching.renamed_os.rename is original_rename
  assert _test_patching.renamed_path.dirname is original_dirname
  assert _test_patching.renamed_os.path.dirname is original_dirname

 # check that everthing is back to normal when the patch is over

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 assert _test_patching.open is open

 lowerCAmelCase__     :   Optional[Any]     		=	"__test_patch_submodule_builtin_mock__"
 # _test_patching has "open" in its globals
 assert _test_patching.open is open
 with patch_submodule(_test_patching      ,			"open"      ,			lowerCamelCase_			):
  assert _test_patching.open is mock

 # check that everthing is back to normal when the patch is over

 assert _test_patching.open is open


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	"__test_patch_submodule_missing_mock__"
 with patch_submodule(_test_patching      ,			"pandas.read_csv"      ,			lowerCamelCase_			):
  pass


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 lowerCAmelCase__     :   Optional[int]     		=	"__test_patch_submodule_missing_builtin_mock__"
 # _test_patching doesn't have "len" in its globals
 assert getattr(_test_patching      ,			"len"      ,			lowerCamelCase_			) is None
 with patch_submodule(_test_patching      ,			"len"      ,			lowerCamelCase_			):
  assert _test_patching.len is mock
 assert _test_patching.len is len


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	"__test_patch_submodule_start_and_stop_mock__"
 lowerCAmelCase__     :   Tuple     		=	patch_submodule(_test_patching      ,			"open"      ,			lowerCamelCase_			)
 assert _test_patching.open is open
 patch.start()
 assert _test_patching.open is mock
 patch.stop()
 assert _test_patching.open is open


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 lowerCAmelCase__     :   List[str]     		=	"__test_patch_submodule_successive_join__"
 lowerCAmelCase__     :   str     		=	"__test_patch_submodule_successive_dirname__"
 lowerCAmelCase__     :   Optional[Any]     		=	"__test_patch_submodule_successive_rename__"
 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename

 with patch_submodule(_test_patching      ,			"os.path.join"      ,			lowerCamelCase_			):
  with patch_submodule(_test_patching      ,			"os.rename"      ,			lowerCamelCase_			):
   with patch_submodule(_test_patching      ,			"os.path.dirname"      ,			lowerCamelCase_			):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

    # try another order
 with patch_submodule(_test_patching      ,			"os.rename"      ,			lowerCamelCase_			):
  with patch_submodule(_test_patching      ,			"os.path.join"      ,			lowerCamelCase_			):
   with patch_submodule(_test_patching      ,			"os.path.dirname"      ,			lowerCamelCase_			):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename







def        UpperCAmelCase_ (  ):







 """simple docstring"""


 lowerCAmelCase__     :   Optional[Any]     		=	"__test_patch_submodule_doesnt_exist_mock__"
 with patch_submodule(_test_patching      ,			"__module_that_doesn_exist__.__attribute_that_doesn_exist__"      ,			lowerCamelCase_			):
  pass
 with patch_submodule(_test_patching      ,			"os.__attribute_that_doesn_exist__"      ,			lowerCamelCase_			):
  pass







'''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.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool




class    lowerCAmelCase       (     UpperCamelCase_  ):
 A_				:				int	=			"""openai/whisper-base"""
 A_				:				str	=			(
     """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """
     """transcribed text."""
 )
 A_				:				Union[str, Any]	=			"""transcriber"""
 A_				:				Tuple	=			WhisperProcessor
 A_				:				Dict	=			WhisperForConditionalGeneration

 A_				:				Tuple	=			["""audio"""]
 A_				:				Optional[int]	=			["""text"""]


 def    _A	(    self  : Optional[int]			,							a__  : Optional[int]    ):
  '''simple docstring'''

  return self.pre_processor(a__			,							return_tensors="pt"    ).input_features


 def    _A	(    self  : List[str]			,							a__  : Union[str, Any]    ):
  '''simple docstring'''

  return self.model.generate(inputs=a__    )


 def    _A	(    self  : Optional[Any]			,							a__  : Dict    ):
  '''simple docstring'''

  return self.pre_processor.batch_decode(a__			,							skip_special_tokens=a__    )[0]





