


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        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		MODEL_FOR_CAUSAL_LM_MAPPING
			_UpperCamelCase		:					Tuple    =		TF_MODEL_FOR_CAUSAL_LM_MAPPING




			@require_torch
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						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=snake_case     )
						self.assertEqual(
						    snake_case      ,						[
						        {
						            "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(
						    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@@"
						                )
						            }
						        ],
						    ]      ,						)

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




			@require_tf
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						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=snake_case     )
						self.assertEqual(
						    snake_case      ,						[
						        {
						            "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=snake_case     )
						self.assertEqual(
						    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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       TextGenerationPipeline(model=snake_case      ,						tokenizer=snake_case     )
						return text_generator, ["This is a test", "Another test"]




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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

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




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       text_generator.model
						UpperCamelCase__					=       text_generator.tokenizer

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

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

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

						UpperCamelCase__					=       text_generator("This is a test"      ,						return_full_text=snake_case     )
						self.assertEqual(snake_case      ,						[{"generated_text": ANY(snake_case     )}]     )
						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=snake_case     )
						self.assertEqual(
						    snake_case      ,						[
						        [{"generated_text": ANY(snake_case     )}, {"generated_text": ANY(snake_case     )}],
						        [{"generated_text": ANY(snake_case     )}, {"generated_text": ANY(snake_case     )}],
						    ]      ,						)

						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=snake_case     )
									self.assertEqual(
									    snake_case      ,						[
									        [{"generated_text": ANY(snake_case     )}, {"generated_text": ANY(snake_case     )}],
									        [{"generated_text": ANY(snake_case     )}, {"generated_text": ANY(snake_case     )}],
									    ]      ,						)

						with self.assertRaises(snake_case     ):
									UpperCamelCase__					=       text_generator("test"      ,						return_full_text=snake_case      ,						return_text=snake_case     )
						with self.assertRaises(snake_case     ):
									UpperCamelCase__					=       text_generator("test"      ,						return_full_text=snake_case      ,						return_tensors=snake_case     )
						with self.assertRaises(snake_case     ):
									UpperCamelCase__					=       text_generator("test"      ,						return_text=snake_case      ,						return_tensors=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__
						):
									UpperCamelCase__					=       text_generator(""     )
									self.assertEqual(snake_case      ,						[{"generated_text": ANY(snake_case     )}]     )
						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 < 10000
						    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(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 				snake_case__				(							self     ):

						'''simple docstring'''


						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(
						    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.)
						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(
						    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
						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(
						    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 				snake_case__				(							self     ):

						'''simple docstring'''


						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 				snake_case__				(							self     ):

						'''simple docstring'''


						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=snake_case      ,						top_p=0.5     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						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(snake_case     ) as cl:
									UpperCamelCase__					=       text_generator(snake_case      ,						max_length=10      ,						max_new_tokens=1     )
						self.assertIn(snake_case      ,						cl.out     )

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

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






from collections import OrderedDict
from typing import Mapping

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


__UpperCamelCase    		=       logging.get_logger(__name__)

__UpperCamelCase    		=       {
    'facebook/data2vec-text-base': 'https://huggingface.co/data2vec/resolve/main/config.json',
}







class        lowerCamelCase__	(							UpperCAmelCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					int    =		'data2vec-text'




			def __init__(							self      ,						snake_case=30522      ,						snake_case=768      ,						snake_case=12      ,						snake_case=12      ,						snake_case=3072      ,						snake_case="gelu"      ,						snake_case=0.1      ,						snake_case=0.1      ,						snake_case=512      ,						snake_case=2      ,						snake_case=0.02      ,						snake_case=1E-1_2      ,						snake_case=1      ,						snake_case=0      ,						snake_case=2      ,						snake_case="absolute"      ,						snake_case=True      ,						snake_case=None      ,						**snake_case      ,						):

						'''simple docstring'''


						super().__init__(pad_token_id=snake_case      ,						bos_token_id=snake_case      ,						eos_token_id=snake_case      ,						**snake_case     )

						UpperCamelCase__					=       vocab_size
						UpperCamelCase__					=       hidden_size
						UpperCamelCase__					=       num_hidden_layers
						UpperCamelCase__					=       num_attention_heads
						UpperCamelCase__					=       hidden_act
						UpperCamelCase__					=       intermediate_size
						UpperCamelCase__					=       hidden_dropout_prob
						UpperCamelCase__					=       attention_probs_dropout_prob
						UpperCamelCase__					=       max_position_embeddings
						UpperCamelCase__					=       type_vocab_size
						UpperCamelCase__					=       initializer_range
						UpperCamelCase__					=       layer_norm_eps
						UpperCamelCase__					=       position_embedding_type
						UpperCamelCase__					=       use_cache
						UpperCamelCase__					=       classifier_dropout







class        lowerCamelCase__	(							UpperCAmelCase      ):






			"""simple docstring"""






			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						if self.task == "multiple-choice":
									UpperCamelCase__					=       {0: "batch", 1: "choice", 2: "sequence"}
						else:
									UpperCamelCase__					=       {0: "batch", 1: "sequence"}
						return OrderedDict(
						    [
						        ("input_ids", dynamic_axis),
						        ("attention_mask", dynamic_axis),
						    ]     )


