




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 			_UpperCamelCase      (				unittest.TestCase		):
						UpperCAmelCase_        =		MODEL_FOR_CAUSAL_LM_MAPPING
						UpperCAmelCase_        =		TF_MODEL_FOR_CAUSAL_LM_MAPPING
						@require_torch
						def 	UpperCAmelCase_						(			self   :List[Any]      )     ->			List[str]:
							UpperCAmelCase__							 =						pipeline(task="text-generation" ,      model="sshleifer/tiny-ctrl" ,      framework="pt"      )
							# Using `do_sample=False` to force deterministic output
							UpperCAmelCase__							 =						text_generator("This is a test" ,      do_sample=lowerCamelCase      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        {
							            "generated_text": (
							                "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
							                " oscope. FiliFili@@"
							            )
							        }
							    ] ,      )

							UpperCAmelCase__							 =						text_generator(["This is a test", "This is a second test"]      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        [
							            {
							                "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@@"
							                )
							            }
							        ],
							    ] ,      )

							UpperCAmelCase__							 =						text_generator("This is a test" ,      do_sample=lowerCamelCase ,      num_return_sequences=2 ,      return_tensors=lowerCamelCase      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        {"generated_token_ids": ANY(lowerCamelCase      )},
							        {"generated_token_ids": ANY(lowerCamelCase      )},
							    ] ,      )
							UpperCAmelCase__							 =						text_generator.model.config.eos_token_id
							UpperCAmelCase__							 =						"<pad>"
							UpperCAmelCase__							 =						text_generator(
							    ["This is a test", "This is a second test"] ,      do_sample=lowerCamelCase ,      num_return_sequences=2 ,      batch_size=2 ,      return_tensors=lowerCamelCase ,      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        [
							            {"generated_token_ids": ANY(lowerCamelCase      )},
							            {"generated_token_ids": ANY(lowerCamelCase      )},
							        ],
							        [
							            {"generated_token_ids": ANY(lowerCamelCase      )},
							            {"generated_token_ids": ANY(lowerCamelCase      )},
							        ],
							    ] ,      )
						@require_tf
						def 	UpperCAmelCase_						(			self   :Tuple      )     ->			Optional[int]:
							UpperCAmelCase__							 =						pipeline(task="text-generation" ,      model="sshleifer/tiny-ctrl" ,      framework="tf"      )

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

							UpperCAmelCase__							 =						text_generator(["This is a test", "This is a second test"] ,      do_sample=lowerCamelCase      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        [
							            {
							                "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 	UpperCAmelCase_						(			self   :int ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :List[Any]      )     ->			Union[str, Any]:
							UpperCAmelCase__							 =						TextGenerationPipeline(model=lowerCamelCase ,      tokenizer=lowerCamelCase      )
							return text_generator, ["This is a test", "Another test"]
						def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			Dict:
							UpperCAmelCase__							 =						"Hello I believe in"
							UpperCAmelCase__							 =						pipeline("text-generation" ,      model="hf-internal-testing/tiny-random-gpt2"      )
							UpperCAmelCase__							 =						text_generator(lowerCamelCase      )
							self.assertEqual(
							    lowerCamelCase ,      [{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}] ,      )

							UpperCAmelCase__							 =						text_generator(lowerCamelCase ,      stop_sequence=" fe"      )
							self.assertEqual(lowerCamelCase ,      [{"generated_text": "Hello I believe in fe"}]      )
						def 	UpperCAmelCase_						(			self   :Dict ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Dict      )     ->			Any:
							UpperCAmelCase__							 =						text_generator.model
							UpperCAmelCase__							 =						text_generator.tokenizer

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

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

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

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

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

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

							with self.assertRaises(lowerCamelCase      ):
								UpperCAmelCase__							 =						text_generator("test" ,      return_full_text=lowerCamelCase ,      return_text=lowerCamelCase      )
							with self.assertRaises(lowerCamelCase      ):
								UpperCAmelCase__							 =						text_generator("test" ,      return_full_text=lowerCamelCase ,      return_tensors=lowerCamelCase      )
							with self.assertRaises(lowerCamelCase      ):
								UpperCAmelCase__							 =						text_generator("test" ,      return_text=lowerCamelCase ,      return_tensors=lowerCamelCase      )

							# 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__
							):
								UpperCAmelCase__							 =						text_generator(""      )
								self.assertEqual(lowerCamelCase ,      [{"generated_text": ANY(lowerCamelCase      )}]      )
							else:
								with self.assertRaises((ValueError, AssertionError)      ):
									UpperCAmelCase__							 =						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.
							UpperCAmelCase__							 =						["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      )

								UpperCAmelCase__							 =						text_generator("This is a test" * 500 ,      handle_long_generation="hole" ,      max_new_tokens=20      )
								# Hole strategy cannot work
								with self.assertRaises(lowerCamelCase      ):
									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 	UpperCAmelCase_						(			self   :Tuple      )     ->			Optional[Any]:
							import torch

							# Classic `model_kwargs`
							UpperCAmelCase__							 =						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      )
							UpperCAmelCase__							 =						pipe("This is a test"      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        {
							            "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.)
							UpperCAmelCase__							 =						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      )
							UpperCAmelCase__							 =						pipe("This is a test"      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        {
							            "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
							UpperCAmelCase__							 =						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      )
							UpperCAmelCase__							 =						pipe("This is a test"      )
							self.assertEqual(
							    lowerCamelCase ,      [
							        {
							            "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 	UpperCAmelCase_						(			self   :int      )     ->			int:
							import torch

							UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			Optional[Any]:
							import torch

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







						def 	UpperCAmelCase_						(			self   :Dict      )     ->			str:
							UpperCAmelCase__							 =						"Hello world"
							UpperCAmelCase__							 =						pipeline("text-generation" ,      model="hf-internal-testing/tiny-random-gpt2"      )
							if text_generator.model.framework == "tf":
								UpperCAmelCase__							 =						logging.get_logger("transformers.generation.tf_utils"      )
							else:
								UpperCAmelCase__							 =						logging.get_logger("transformers.generation.utils"      )
							UpperCAmelCase__							 =						"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(lowerCamelCase      ) as cl:
								UpperCAmelCase__							 =						text_generator(lowerCamelCase ,      max_length=10 ,      max_new_tokens=1      )
							self.assertIn(lowerCamelCase ,      cl.out      )

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

							with CaptureLogger(lowerCamelCase      ) as cl:
								UpperCAmelCase__							 =						text_generator(lowerCamelCase ,      max_length=10      )
							self.assertNotIn(lowerCamelCase ,      cl.out      )











import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()



def 						lowerCAmelCase		(		_lowerCAmelCase							:   Any						,							_lowerCAmelCase							:   List[str]						,							_lowerCAmelCase							:   Optional[int]						,							_lowerCAmelCase							:   Union[str, Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						BigBirdConfig.from_json_file(_lowerCAmelCase	)
 print(F'''Building PyTorch model from configuration: {config}'''	)

 if is_trivia_qa:
  UpperCAmelCase__							 =						BigBirdForQuestionAnswering(_lowerCAmelCase	)
 else:
  UpperCAmelCase__							 =						BigBirdForPreTraining(_lowerCAmelCase	)

 # Load weights from tf checkpoint
 load_tf_weights_in_big_bird(_lowerCAmelCase						,							_lowerCAmelCase						,							is_trivia_qa=_lowerCAmelCase	)

 # Save pytorch-model
 print(F'''Save PyTorch model to {pytorch_dump_path}'''	)
 model.save_pretrained(_lowerCAmelCase	)


if __name__ == "__main__":
  _lowerCAmelCase						:   List[Any]		=   argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
  )
  parser.add_argument(
      "--big_bird_config_file",
      default=None,
      type=str,
      required=True,
      help=(
          "The config json file corresponding to the pre-trained BERT model. \n"
          "This specifies the model architecture."
      ),
  )
  parser.add_argument(
      "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
  )
  parser.add_argument(
      "--is_trivia_qa", action="store_true", help="Whether to convert a model with a trivia_qa head."
  )
  _lowerCAmelCase						:   Dict		=   parser.parse_args()
  convert_tf_checkpoint_to_pytorch(
      args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
  )





