

import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def        __lowerCAmelCase    (       )		->							int:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			ArgumentParser(
     description=(
         'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
     )	)

 # Optional arguments for the launch helper
 parser.add_argument('--num_cores'		,							type=_UpperCamelCase		,							default=1		,							help='Number of TPU cores to use (1 or 8).'	)

 # positional
 parser.add_argument(
     'training_script'		,							type=_UpperCamelCase		,							help=(
         'The full path to the single TPU training '
         'program/script to be launched in parallel, '
         'followed by all the arguments for the '
         'training script'
     )		,							)

 # rest from the training program
 parser.add_argument('training_script_args'		,							nargs=_UpperCamelCase	)

 return parser.parse_args()


def        __lowerCAmelCase    (       )		->							List[str]:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			parse_args()

 # Import training_script as a module.
 SCREAMING_SNAKE_CASE								=			Path(args.training_script	)
 sys.path.append(str(script_fpath.parent.resolve()	)	)
 SCREAMING_SNAKE_CASE								=			script_fpath.stem
 SCREAMING_SNAKE_CASE								=			importlib.import_module(_UpperCamelCase	)

 # Patch sys.argv
 SCREAMING_SNAKE_CASE								=			[args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores	)]

 xmp.spawn(mod._mp_fn		,							args=()		,							nprocs=args.num_cores	)


if __name__ == "__main__":
      main()




# 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      UpperCamelCase (     SCREAMING_SNAKE_CASE   ):
    __UpperCamelCase         ="openai/whisper-base"
    __UpperCamelCase         =(
        "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the "
        "transcribed text."
    )
    __UpperCamelCase         ="transcriber"
    __UpperCamelCase         =WhisperProcessor
    __UpperCamelCase         =WhisperForConditionalGeneration

    __UpperCamelCase         =["audio"]
    __UpperCamelCase         =["text"]

    def UpperCamelCase			(			self :      Dict							,    snake_case__ :      Tuple    ):

     """simple docstring"""






     return self.pre_processor(snake_case__							,    return_tensors='pt'    ).input_features

    def UpperCamelCase			(			self :      Optional[int]							,    snake_case__ :      Tuple    ):

     """simple docstring"""






     return self.model.generate(inputs=snake_case__    )




    def UpperCamelCase			(			self :      str							,    snake_case__ :      Union[str, Any]    ):

     """simple docstring"""






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

