



"""simple docstring"""
import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY
@is_pipeline_test
@require_torch_or_tf
class 					a	(  unittest.TestCase       ):
  UpperCamelCase	:				List[Any]     						=					MODEL_FOR_CAUSAL_LM_MAPPING
  UpperCamelCase	:				List[str]     						=					TF_MODEL_FOR_CAUSAL_LM_MAPPING



  @require_torch
  def 	lowerCamelCase__       (						self :					Dict		)     ->					Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=pipeline(task="""text-generation"""       ,		model="""sshleifer/tiny-ctrl"""       ,		framework="""pt"""		)
     # Using `do_sample=False` to force deterministic output
     SCREAMING_SNAKE_CASE_: Tuple     			=text_generator("""This is a test"""       ,		do_sample=__a		)
     self.assertEqual(
         __a       ,		[
             {
                 """generated_text""": (
                     """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                     """ oscope. FiliFili@@"""
                 )
             }
         ]       ,		)

     SCREAMING_SNAKE_CASE_: List[str]     			=text_generator(["""This is a test""", """This is a second test"""]		)
     self.assertEqual(
         __a       ,		[
             [
                 {
                     """generated_text""": (
                         """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                         """ oscope. FiliFili@@"""
                     )
                 }
             ],
             [
                 {
                     """generated_text""": (
                         """This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"""
                         """ oscope. oscope. FiliFili@@"""
                     )
                 }
             ],
         ]       ,		)

     SCREAMING_SNAKE_CASE_: List[str]     			=text_generator("""This is a test"""       ,		do_sample=__a       ,		num_return_sequences=2       ,		return_tensors=__a		)
     self.assertEqual(
         __a       ,		[
             {"""generated_token_ids""": ANY(__a		)},
             {"""generated_token_ids""": ANY(__a		)},
         ]       ,		)
     SCREAMING_SNAKE_CASE_: Tuple     			=text_generator.model.config.eos_token_id
     SCREAMING_SNAKE_CASE_: Tuple     			="""<pad>"""
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=text_generator(
         ["""This is a test""", """This is a second test"""]       ,		do_sample=__a       ,		num_return_sequences=2       ,		batch_size=2       ,		return_tensors=__a       ,		)
     self.assertEqual(
         __a       ,		[
             [
                 {"""generated_token_ids""": ANY(__a		)},
                 {"""generated_token_ids""": ANY(__a		)},
             ],
             [
                 {"""generated_token_ids""": ANY(__a		)},
                 {"""generated_token_ids""": ANY(__a		)},
             ],
         ]       ,		)



  @require_tf
  def 	lowerCamelCase__       (						self :					Optional[int]		)     ->					str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=pipeline(task="""text-generation"""       ,		model="""sshleifer/tiny-ctrl"""       ,		framework="""tf"""		)

     # Using `do_sample=False` to force deterministic output
     SCREAMING_SNAKE_CASE_: str     			=text_generator("""This is a test"""       ,		do_sample=__a		)
     self.assertEqual(
         __a       ,		[
             {
                 """generated_text""": (
                     """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                     """ please,"""
                 )
             }
         ]       ,		)

     SCREAMING_SNAKE_CASE_: Optional[Any]     			=text_generator(["""This is a test""", """This is a second test"""]       ,		do_sample=__a		)
     self.assertEqual(
         __a       ,		[
             [
                 {
                     """generated_text""": (
                         """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                         """ please,"""
                     )
                 }
             ],
             [
                 {
                     """generated_text""": (
                         """This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"""
                         """ Cannes 閲閲Cannes Cannes Cannes 攵 please,"""
                     )
                 }
             ],
         ]       ,		)



  def 	lowerCamelCase__       (						self :					Tuple       ,		lowerCAmelCase :					Optional[int]       ,		lowerCAmelCase :					List[Any]       ,		lowerCAmelCase :					Optional[Any]		)     ->					Optional[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: List[str]     			=TextGenerationPipeline(model=__a       ,		tokenizer=__a		)
     return text_generator, ["This is a test", "Another test"]



  def 	lowerCamelCase__       (						self :					Union[str, Any]		)     ->					Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			="""Hello I believe in"""
     SCREAMING_SNAKE_CASE_: str     			=pipeline("""text-generation"""       ,		model="""hf-internal-testing/tiny-random-gpt2"""		)
     SCREAMING_SNAKE_CASE_: Tuple     			=text_generator(__a		)
     self.assertEqual(
         __a       ,		[{"""generated_text""": """Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"""}]       ,		)

     SCREAMING_SNAKE_CASE_: List[str]     			=text_generator(__a       ,		stop_sequence=""" fe"""		)
     self.assertEqual(__a       ,		[{"""generated_text""": """Hello I believe in fe"""}]		)



  def 	lowerCamelCase__       (						self :					int       ,		lowerCAmelCase :					Optional[int]       ,		lowerCAmelCase :					Optional[int]		)     ->					Union[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Tuple     			=text_generator.model
     SCREAMING_SNAKE_CASE_: Any     			=text_generator.tokenizer

     SCREAMING_SNAKE_CASE_: List[str]     			=text_generator("""This is a test"""		)
     self.assertEqual(__a       ,		[{"""generated_text""": ANY(__a		)}]		)
     self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""		)		)

     SCREAMING_SNAKE_CASE_: Tuple     			=text_generator("""This is a test"""       ,		return_full_text=__a		)
     self.assertEqual(__a       ,		[{"""generated_text""": ANY(__a		)}]		)
     self.assertNotIn("""This is a test"""       ,		outputs[0]["""generated_text"""]		)

     SCREAMING_SNAKE_CASE_: Optional[int]     			=pipeline(task="""text-generation"""       ,		model=__a       ,		tokenizer=__a       ,		return_full_text=__a		)
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=text_generator("""This is a test"""		)
     self.assertEqual(__a       ,		[{"""generated_text""": ANY(__a		)}]		)
     self.assertNotIn("""This is a test"""       ,		outputs[0]["""generated_text"""]		)

     SCREAMING_SNAKE_CASE_: List[str]     			=text_generator("""This is a test"""       ,		return_full_text=__a		)
     self.assertEqual(__a       ,		[{"""generated_text""": ANY(__a		)}]		)
     self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""		)		)

     SCREAMING_SNAKE_CASE_: Any     			=text_generator(["""This is great !""", """Something else"""]       ,		num_return_sequences=2       ,		do_sample=__a		)
     self.assertEqual(
         __a       ,		[
             [{"""generated_text""": ANY(__a		)}, {"""generated_text""": ANY(__a		)}],
             [{"""generated_text""": ANY(__a		)}, {"""generated_text""": ANY(__a		)}],
         ]       ,		)

     if text_generator.tokenizer.pad_token is not None:
        SCREAMING_SNAKE_CASE_: Union[str, Any]     			=text_generator(
            ["""This is great !""", """Something else"""]       ,		num_return_sequences=2       ,		batch_size=2       ,		do_sample=__a		)
        self.assertEqual(
            __a       ,		[
                [{"""generated_text""": ANY(__a		)}, {"""generated_text""": ANY(__a		)}],
                [{"""generated_text""": ANY(__a		)}, {"""generated_text""": ANY(__a		)}],
            ]       ,		)

     with self.assertRaises(__a		):
        SCREAMING_SNAKE_CASE_: Any     			=text_generator("""test"""       ,		return_full_text=__a       ,		return_text=__a		)
     with self.assertRaises(__a		):
        SCREAMING_SNAKE_CASE_: Union[str, Any]     			=text_generator("""test"""       ,		return_full_text=__a       ,		return_tensors=__a		)
     with self.assertRaises(__a		):
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=text_generator("""test"""       ,		return_text=__a       ,		return_tensors=__a		)

     # Empty prompt is slighly special
     # it requires BOS token to exist.
     # Special case for Pegasus which will always append EOS so will
     # work even without BOS.
     if (
         text_generator.tokenizer.bos_token_id is not None
         or "Pegasus" in tokenizer.__class__.__name__
         or "Git" in model.__class__.__name__
     ):
        SCREAMING_SNAKE_CASE_: Dict     			=text_generator(""""""		)
        self.assertEqual(__a       ,		[{"""generated_text""": ANY(__a		)}]		)
     else:
        with self.assertRaises((ValueError, AssertionError)		):
           SCREAMING_SNAKE_CASE_: int     			=text_generator(""""""		)

     if text_generator.framework == "tf":
        # TF generation does not support max_new_tokens, and it's impossible
        # to control long generation with only max_length without
        # fancy calculation, dismissing tests for now.
        return
     # We don't care about infinite range models.
     # They already work.
     # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
     SCREAMING_SNAKE_CASE_: Tuple     			=["""RwkvForCausalLM""", """XGLMForCausalLM""", """GPTNeoXForCausalLM"""]
     if (
         tokenizer.model_max_length < 1_0000
         and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
     ):
        # Handling of large generations
        with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)		):
           text_generator("""This is a test""" * 500       ,		max_new_tokens=20		)

        SCREAMING_SNAKE_CASE_: List[Any]     			=text_generator("""This is a test""" * 500       ,		handle_long_generation="""hole"""       ,		max_new_tokens=20		)
        # Hole strategy cannot work
        with self.assertRaises(__a		):
           text_generator(
               """This is a test""" * 500       ,		handle_long_generation="""hole"""       ,		max_new_tokens=tokenizer.model_max_length + 10       ,		)



  @require_torch
  @require_accelerate
  @require_torch_gpu
  def 	lowerCamelCase__       (						self :					List[str]		)     ->					str:


     '''simple docstring'''




     import torch

     # Classic `model_kwargs`
     SCREAMING_SNAKE_CASE_: Tuple     			=pipeline(
         model="""hf-internal-testing/tiny-random-bloom"""       ,		model_kwargs={"""device_map""": """auto""", """torch_dtype""": torch.bfloataa}       ,		)
     self.assertEqual(pipe.model.device       ,		torch.device(0		)		)
     self.assertEqual(pipe.model.lm_head.weight.dtype       ,		torch.bfloataa		)
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=pipe("""This is a test"""		)
     self.assertEqual(
         __a       ,		[
             {
                 """generated_text""": (
                     """This is a test test test test test test test test test test test test test test test test"""
                     """ test"""
                 )
             }
         ]       ,		)

     # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
     SCREAMING_SNAKE_CASE_: Optional[int]     			=pipeline(model="""hf-internal-testing/tiny-random-bloom"""       ,		device_map="""auto"""       ,		torch_dtype=torch.bfloataa		)
     self.assertEqual(pipe.model.device       ,		torch.device(0		)		)
     self.assertEqual(pipe.model.lm_head.weight.dtype       ,		torch.bfloataa		)
     SCREAMING_SNAKE_CASE_: Optional[int]     			=pipe("""This is a test"""		)
     self.assertEqual(
         __a       ,		[
             {
                 """generated_text""": (
                     """This is a test test test test test test test test test test test test test test test test"""
                     """ test"""
                 )
             }
         ]       ,		)

     # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
     SCREAMING_SNAKE_CASE_: Dict     			=pipeline(model="""hf-internal-testing/tiny-random-bloom"""       ,		device_map="""auto"""		)
     self.assertEqual(pipe.model.device       ,		torch.device(0		)		)
     self.assertEqual(pipe.model.lm_head.weight.dtype       ,		torch.floataa		)
     SCREAMING_SNAKE_CASE_: Tuple     			=pipe("""This is a test"""		)
     self.assertEqual(
         __a       ,		[
             {
                 """generated_text""": (
                     """This is a test test test test test test test test test test test test test test test test"""
                     """ test"""
                 )
             }
         ]       ,		)



  @require_torch
  @require_torch_gpu
  def 	lowerCamelCase__       (						self :					Union[str, Any]		)     ->					Union[str, Any]:


     '''simple docstring'''




     import torch

     SCREAMING_SNAKE_CASE_: Optional[int]     			=pipeline(model="""hf-internal-testing/tiny-random-bloom"""       ,		device=0       ,		torch_dtype=torch.floataa		)
     pipe("""This is a test"""		)



  @require_torch
  @require_accelerate
  @require_torch_gpu
  def 	lowerCamelCase__       (						self :					int		)     ->					Union[str, Any]:


     '''simple docstring'''




     import torch

     SCREAMING_SNAKE_CASE_: Any     			=pipeline(model="""hf-internal-testing/tiny-random-bloom"""       ,		device_map="""auto"""       ,		torch_dtype=torch.floataa		)
     pipe("""This is a test"""       ,		do_sample=__a       ,		top_p=0.5		)





  def 	lowerCamelCase__       (						self :					Dict		)     ->					Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: str     			="""Hello world"""
     SCREAMING_SNAKE_CASE_: List[Any]     			=pipeline("""text-generation"""       ,		model="""hf-internal-testing/tiny-random-gpt2"""		)
     if text_generator.model.framework == "tf":
        SCREAMING_SNAKE_CASE_: List[str]     			=logging.get_logger("""transformers.generation.tf_utils"""		)
     else:
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=logging.get_logger("""transformers.generation.utils"""		)
     SCREAMING_SNAKE_CASE_: List[Any]     			="""Both `max_new_tokens`"""  # The beggining of the message to be checked in this test

     # Both are set by the user -> log warning
     with CaptureLogger(__a		) as cl:
        SCREAMING_SNAKE_CASE_: Any     			=text_generator(__a       ,		max_length=10       ,		max_new_tokens=1		)
     self.assertIn(__a       ,		cl.out		)

     # The user only sets one -> no warning
     with CaptureLogger(__a		) as cl:
        SCREAMING_SNAKE_CASE_: Tuple     			=text_generator(__a       ,		max_new_tokens=1		)
     self.assertNotIn(__a       ,		cl.out		)

     with CaptureLogger(__a		) as cl:
        SCREAMING_SNAKE_CASE_: Optional[int]     			=text_generator(__a       ,		max_length=10		)
     self.assertNotIn(__a       ,		cl.out		)








"""simple docstring"""
import argparse

import numpy as np
import torch

from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging


logging.set_verbosity_info()
_UpperCAmelCase     =			logging.get_logger("""transformers.models.speecht5""")





def      __magic_name__				(							lowercase							,			lowercase							,			lowercase ):
   hf_model.apply_weight_norm()

   SCREAMING_SNAKE_CASE_: Tuple     			=checkpoint["""input_conv.weight_g"""]
   SCREAMING_SNAKE_CASE_: Optional[int]     			=checkpoint["""input_conv.weight_v"""]
   SCREAMING_SNAKE_CASE_: Optional[int]     			=checkpoint["""input_conv.bias"""]

   for i in range(len(config.upsample_rates ) ):
      SCREAMING_SNAKE_CASE_: Any     			=checkpoint[f'''upsamples.{i}.1.weight_g''']
      SCREAMING_SNAKE_CASE_: Any     			=checkpoint[f'''upsamples.{i}.1.weight_v''']
      SCREAMING_SNAKE_CASE_: List[str]     			=checkpoint[f'''upsamples.{i}.1.bias''']

   for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ):
      for j in range(len(config.resblock_dilation_sizes ) ):
         SCREAMING_SNAKE_CASE_: Dict     			=checkpoint[f'''blocks.{i}.convs1.{j}.1.weight_g''']
         SCREAMING_SNAKE_CASE_: Any     			=checkpoint[f'''blocks.{i}.convs1.{j}.1.weight_v''']
         SCREAMING_SNAKE_CASE_: Union[str, Any]     			=checkpoint[f'''blocks.{i}.convs1.{j}.1.bias''']

         SCREAMING_SNAKE_CASE_: Dict     			=checkpoint[f'''blocks.{i}.convs2.{j}.1.weight_g''']
         SCREAMING_SNAKE_CASE_: Any     			=checkpoint[f'''blocks.{i}.convs2.{j}.1.weight_v''']
         SCREAMING_SNAKE_CASE_: List[Any]     			=checkpoint[f'''blocks.{i}.convs2.{j}.1.bias''']

   SCREAMING_SNAKE_CASE_: Tuple     			=checkpoint["""output_conv.1.weight_g"""]
   SCREAMING_SNAKE_CASE_: List[str]     			=checkpoint["""output_conv.1.weight_v"""]
   SCREAMING_SNAKE_CASE_: Optional[int]     			=checkpoint["""output_conv.1.bias"""]

   hf_model.remove_weight_norm()





@torch.no_grad()
def      __magic_name__				(							lowercase							,			lowercase							,			lowercase							,			lowercase=None							,			lowercase=None							,			):
   if config_path is not None:
      SCREAMING_SNAKE_CASE_: List[Any]     			=SpeechTaHifiGanConfig.from_pretrained(lowercase )
   else:
      SCREAMING_SNAKE_CASE_: Optional[Any]     			=SpeechTaHifiGanConfig()

   SCREAMING_SNAKE_CASE_: Union[str, Any]     			=SpeechTaHifiGan(lowercase )

   SCREAMING_SNAKE_CASE_: Any     			=torch.load(lowercase )
   load_weights(orig_checkpoint["""model"""]["""generator"""]							,			lowercase							,			lowercase )

   SCREAMING_SNAKE_CASE_: List[Any]     			=np.load(lowercase )
   SCREAMING_SNAKE_CASE_: Any     			=stats[0].reshape(-1 )
   SCREAMING_SNAKE_CASE_: str     			=stats[1].reshape(-1 )
   SCREAMING_SNAKE_CASE_: Dict     			=torch.from_numpy(lowercase ).float()
   SCREAMING_SNAKE_CASE_: Dict     			=torch.from_numpy(lowercase ).float()

   model.save_pretrained(lowercase )

   if repo_id:
      print("""Pushing to the hub...""" )
      model.push_to_hub(lowercase )


if __name__ == "__main__":
   _UpperCAmelCase     =			argparse.ArgumentParser()
   parser.add_argument("""--checkpoint_path""", required=True, default=None, type=str, help="""Path to original checkpoint""")
   parser.add_argument("""--stats_path""", required=True, default=None, type=str, help="""Path to stats.npy file""")
   parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
   parser.add_argument(
       """--pytorch_dump_folder_path""", required=True, default=None, type=str, help="""Path to the output PyTorch model."""
   )
   parser.add_argument(
       """--push_to_hub""", default=None, type=str, help="""Where to upload the converted model on the 🤗 hub."""
   )

   _UpperCAmelCase     =			parser.parse_args()
   convert_hifigan_checkpoint(
       args.checkpoint_path,
       args.stats_path,
       args.pytorch_dump_folder_path,
       args.config_path,
       args.push_to_hub,
   )



