




'''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  _snake_case		(	unittest.TestCase							):
			lowerCAmelCase_     :      Optional[Any]						       =    MODEL_FOR_CAUSAL_LM_MAPPING
			lowerCAmelCase_     :      Optional[Any]						       =    TF_MODEL_FOR_CAUSAL_LM_MAPPING




			@require_torch
			def    lowerCAmelCase__				(					self							)				->				Optional[Any]:

										'''simple docstring'''




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

										snake_case_						=      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__							)},
										    ]				,							)
										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=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							)				->				Tuple:

										'''simple docstring'''




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

										'''simple docstring'''




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




			def    lowerCAmelCase__				(					self							)				->				Optional[Any]:

										'''simple docstring'''




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

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




			def    lowerCAmelCase__				(					self				,							a__				,							a__							)				->				Tuple:

										'''simple docstring'''




										snake_case_						=      text_generator.model
										snake_case_						=      text_generator.tokenizer

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

										snake_case_						=      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"]							)

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

										snake_case_						=      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"							)							)

										snake_case_						=      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:
																	snake_case_						=      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__							):
																	snake_case_						=      text_generator("test"				,							return_full_text=a__				,							return_text=a__							)
										with self.assertRaises(a__							):
																	snake_case_						=      text_generator("test"				,							return_full_text=a__				,							return_tensors=a__							)
										with self.assertRaises(a__							):
																	snake_case_						=      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__
										):
																	snake_case_						=      text_generator(""							)
																	self.assertEqual(a__				,							[{"generated_text": ANY(a__							)}]							)
										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(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							)				->				Optional[Any]:

										'''simple docstring'''




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

										'''simple docstring'''




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

										'''simple docstring'''




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




			def    lowerCAmelCase__				(					self							)				->				Tuple:

										'''simple docstring'''




										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(a__							) as cl:
																	snake_case_						=      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:
																	snake_case_						=      text_generator(a__				,							max_new_tokens=1							)
										self.assertNotIn(a__				,							cl.out							)

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






from PIL import Image




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Image						,  _lowerCamelCase :			int)					->    Image:






							'''simple docstring'''





							__UpperCamelCase	:   str			   =					(259 * (level + 255)) / (255 * (259 - level))

							def contrast(_lowerCamelCase :			int) -> int:
														return int(128 + factor * (c - 128))

							return img.point(_lowerCamelCase)


if __name__ == "__main__":
		# Load image
		with Image.open('image_data/lena.jpg') as img:
				# Change contrast to 170
				lowercase  :					Tuple													=       change_contrast(img, 170)
				cont_img.save('image_data/lena_high_contrast.png', format='png')