


import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
       import torch





class 			lowerCAmelCase__(     unittest.TestCase     ,     snake_case__    ):






    '''simple docstring'''





    def        _lowerCamelCase			(						self					: Dict						):





       '''simple docstring'''
       UpperCAmelCase_				:   Dict							= load_tool('''speech-to-text'''						)
       self.tool.setup()





    def        _lowerCamelCase			(						self					: List[Any]						):





       '''simple docstring'''
       UpperCAmelCase_				:   Dict							= self.tool(torch.ones(3_000						)						)
       self.assertEqual(__snake_case							, ''' you'''						)





    def        _lowerCamelCase			(						self					: str						):





       '''simple docstring'''
       UpperCAmelCase_				:   Dict							= self.tool(audio=torch.ones(3_000						)						)
       self.assertEqual(__snake_case							, ''' you'''						)



import argparse

from transformers import CanineConfig, CanineModel, CanineTokenizer, load_tf_weights_in_canine
from transformers.utils import logging


logging.set_verbosity_info()
def   snake_case_    (			__lowercase      ,							__lowercase							):
   # Initialize PyTorch model
   UpperCAmelCase_				:   Optional[Any]							= CanineConfig()
   UpperCAmelCase_				:   Any							= CanineModel(__lowercase							)
   model.eval()

   print(F'''Building PyTorch model from configuration: {config}'''							)

   # Load weights from tf checkpoint
   load_tf_weights_in_canine(__lowercase      ,							__lowercase      ,							__lowercase							)

   # Save pytorch-model (weights and configuration)
   print(F'''Save PyTorch model to {pytorch_dump_path}'''							)
   model.save_pretrained(__lowercase							)

   # Save tokenizer files
   UpperCAmelCase_				:   List[Any]							= CanineTokenizer()
   print(F'''Save tokenizer files to {pytorch_dump_path}'''							)
   tokenizer.save_pretrained(__lowercase							)


if __name__ == "__main__":
       __UpperCamelCase					:	int          =				argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '--tf_checkpoint_path',
           default=None,
           type=str,
           required=True,
           help='Path to the TensorFlow checkpoint. Should end with model.ckpt',
       )
       parser.add_argument(
           '--pytorch_dump_path',
           default=None,
           type=str,
           required=True,
           help='Path to a folder where the PyTorch model will be placed.',
       )
       __UpperCamelCase					:	str          =				parser.parse_args()
       convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.pytorch_dump_path)