




'''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				):
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		MODEL_FOR_CAUSAL_LM_MAPPING
     SCREAMING_SNAKE_CASE_				:       str       							=		TF_MODEL_FOR_CAUSAL_LM_MAPPING






     @require_torch
     def 							_lowercase      (					self       )				->     Optional[int]:
          _snake_case				= pipeline(task="text-generation"   ,model="sshleifer/tiny-ctrl"   ,framework="pt"       )
          # Using `do_sample=False` to force deterministic output
          _snake_case				= text_generator("This is a test"   ,do_sample=_SCREAMING_SNAKE_CASE       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  {
                      "generated_text": (
                          "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
                          " oscope. FiliFili@@"
                      )
                  }
              ]   ,)

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

          _snake_case				= text_generator("This is a test"   ,do_sample=_SCREAMING_SNAKE_CASE   ,num_return_sequences=2   ,return_tensors=_SCREAMING_SNAKE_CASE       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
                  {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
              ]   ,)
          _snake_case				= text_generator.model.config.eos_token_id
          _snake_case				= "<pad>"
          _snake_case				= text_generator(
              ["This is a test", "This is a second test"]   ,do_sample=_SCREAMING_SNAKE_CASE   ,num_return_sequences=2   ,batch_size=2   ,return_tensors=_SCREAMING_SNAKE_CASE   ,)
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  [
                      {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
                      {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
                  ],
                  [
                      {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
                      {"generated_token_ids": ANY(_SCREAMING_SNAKE_CASE       )},
                  ],
              ]   ,)






     @require_tf
     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= pipeline(task="text-generation"   ,model="sshleifer/tiny-ctrl"   ,framework="tf"       )

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

          _snake_case				= text_generator(["This is a test", "This is a second test"]   ,do_sample=_SCREAMING_SNAKE_CASE       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  [
                      {
                          "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 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     List[str]:
          _snake_case				= TextGenerationPipeline(model=_SCREAMING_SNAKE_CASE   ,tokenizer=_SCREAMING_SNAKE_CASE       )
          return text_generator, ["This is a test", "Another test"]






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				= "Hello I believe in"
          _snake_case				= pipeline("text-generation"   ,model="hf-internal-testing/tiny-random-gpt2"       )
          _snake_case				= text_generator(_SCREAMING_SNAKE_CASE       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]   ,)

          _snake_case				= text_generator(_SCREAMING_SNAKE_CASE   ,stop_sequence=" fe"       )
          self.assertEqual(_SCREAMING_SNAKE_CASE   ,[{"generated_text": "Hello I believe in fe"}]       )






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Any:
          _snake_case				= text_generator.model
          _snake_case				= text_generator.tokenizer

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

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

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

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

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

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

          with self.assertRaises(_SCREAMING_SNAKE_CASE       ):
               _snake_case				= text_generator("test"   ,return_full_text=_SCREAMING_SNAKE_CASE   ,return_text=_SCREAMING_SNAKE_CASE       )
          with self.assertRaises(_SCREAMING_SNAKE_CASE       ):
               _snake_case				= text_generator("test"   ,return_full_text=_SCREAMING_SNAKE_CASE   ,return_tensors=_SCREAMING_SNAKE_CASE       )
          with self.assertRaises(_SCREAMING_SNAKE_CASE       ):
               _snake_case				= text_generator("test"   ,return_text=_SCREAMING_SNAKE_CASE   ,return_tensors=_SCREAMING_SNAKE_CASE       )

          # 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__
          ):
               _snake_case				= text_generator(""       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,[{"generated_text": ANY(_SCREAMING_SNAKE_CASE       )}]       )
          else:
               with self.assertRaises((ValueError, AssertionError)       ):
                    _snake_case				= 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.
          _snake_case				= ["RwkvForCausalLM", "XGLMForCausalLM", "GPTNeoXForCausalLM"]
          if (
              tokenizer.model_max_length < 10_000
              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       )

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

          # Classic `model_kwargs`
          _snake_case				= 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       )
          _snake_case				= pipe("This is a test"       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  {
                      "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.)
          _snake_case				= 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       )
          _snake_case				= pipe("This is a test"       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  {
                      "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
          _snake_case				= 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       )
          _snake_case				= pipe("This is a test"       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,[
                  {
                      "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 							_lowercase      (					self       )				->     str:
          import torch

          _snake_case				= 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 							_lowercase      (					self       )				->     Dict:
          import torch

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






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

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

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








'''simple docstring'''





from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCamelCase_		:     Optional[int]          =		logging.get_logger(__name__)

UpperCamelCase_		:     str          =		{
    '''kssteven/ibert-roberta-base''': '''https://huggingface.co/kssteven/ibert-roberta-base/resolve/main/config.json''',
    '''kssteven/ibert-roberta-large''': '''https://huggingface.co/kssteven/ibert-roberta-large/resolve/main/config.json''',
    '''kssteven/ibert-roberta-large-mnli''': (
        '''https://huggingface.co/kssteven/ibert-roberta-large-mnli/resolve/main/config.json'''
    ),
}

class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       List[Any]       							=		"""ibert"""






     def __init__(					self   ,_SCREAMING_SNAKE_CASE=30_522   ,_SCREAMING_SNAKE_CASE=768   ,_SCREAMING_SNAKE_CASE=12   ,_SCREAMING_SNAKE_CASE=12   ,_SCREAMING_SNAKE_CASE=3_072   ,_SCREAMING_SNAKE_CASE="gelu"   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=512   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE=0.0_2   ,_SCREAMING_SNAKE_CASE=1e-12   ,_SCREAMING_SNAKE_CASE=1   ,_SCREAMING_SNAKE_CASE=0   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE="absolute"   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE="none"   ,**_SCREAMING_SNAKE_CASE   ,)				->     Dict:
          super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE   ,bos_token_id=_SCREAMING_SNAKE_CASE   ,eos_token_id=_SCREAMING_SNAKE_CASE   ,**_SCREAMING_SNAKE_CASE       )

          _snake_case				= vocab_size
          _snake_case				= hidden_size
          _snake_case				= num_hidden_layers
          _snake_case				= num_attention_heads
          _snake_case				= hidden_act
          _snake_case				= intermediate_size
          _snake_case				= hidden_dropout_prob
          _snake_case				= attention_probs_dropout_prob
          _snake_case				= max_position_embeddings
          _snake_case				= type_vocab_size
          _snake_case				= initializer_range
          _snake_case				= layer_norm_eps
          _snake_case				= position_embedding_type
          _snake_case				= quant_mode
          _snake_case				= force_dequant







class   _a							(		__lowerCAmelCase				):






     @property
     def 							_lowercase      (					self       )				->     Mapping[str, Mapping[int, str]]:
          if self.task == "multiple-choice":
               _snake_case				= {0: "batch", 1: "choice", 2: "sequence"}
          else:
               _snake_case				= {0: "batch", 1: "sequence"}
          return OrderedDict(
              [
                  ("input_ids", dynamic_axis),
                  ("attention_mask", dynamic_axis),
              ]       )


