





'''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     ):
							__a					:   str									=       MODEL_FOR_CAUSAL_LM_MAPPING
							__a					:   Any									=       TF_MODEL_FOR_CAUSAL_LM_MAPPING

							@require_torch
							def     UpperCAmelCase__	(							self							:     List[str]   )					->       int:







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

													UpperCAmelCase_			:      Any     						=  text_generator(['''This is a test''', '''This is a second test''']   )
													self.assertEqual(
													    __magic_name__       ,     [
													        [
													            {
													                '''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_			:      List[Any]     						=  text_generator('''This is a test'''       ,     do_sample=__magic_name__       ,     num_return_sequences=2       ,     return_tensors=__magic_name__   )
													self.assertEqual(
													    __magic_name__       ,     [
													        {'''generated_token_ids''': ANY(__magic_name__   )},
													        {'''generated_token_ids''': ANY(__magic_name__   )},
													    ]       ,     )
													UpperCAmelCase_			:      Any     						=  text_generator.model.config.eos_token_id
													UpperCAmelCase_			:      Union[str, Any]     						=  '''<pad>'''
													UpperCAmelCase_			:      List[Any]     						=  text_generator(
													    ['''This is a test''', '''This is a second test''']       ,     do_sample=__magic_name__       ,     num_return_sequences=2       ,     batch_size=2       ,     return_tensors=__magic_name__       ,     )
													self.assertEqual(
													    __magic_name__       ,     [
													        [
													            {'''generated_token_ids''': ANY(__magic_name__   )},
													            {'''generated_token_ids''': ANY(__magic_name__   )},
													        ],
													        [
													            {'''generated_token_ids''': ANY(__magic_name__   )},
													            {'''generated_token_ids''': ANY(__magic_name__   )},
													        ],
													    ]       ,     )

							@require_tf
							def     UpperCAmelCase__	(							self							:     Any   )					->       List[str]:







													"""simple docstring"""
													UpperCAmelCase_			:      str     						=  pipeline(task='''text-generation'''       ,     model='''sshleifer/tiny-ctrl'''       ,     framework='''tf'''   )

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

													UpperCAmelCase_			:      List[Any]     						=  text_generator(['''This is a test''', '''This is a second test''']       ,     do_sample=__magic_name__   )
													self.assertEqual(
													    __magic_name__       ,     [
													        [
													            {
													                '''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							:     Tuple       ,     __magic_name__							:     Union[str, Any]       ,     __magic_name__							:     Any       ,     __magic_name__							:     Any   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  TextGenerationPipeline(model=__magic_name__       ,     tokenizer=__magic_name__   )
													return text_generator, ["This is a test", "Another test"]

							def     UpperCAmelCase__	(							self							:     str   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  '''Hello I believe in'''
													UpperCAmelCase_			:      Optional[int]     						=  pipeline('''text-generation'''       ,     model='''hf-internal-testing/tiny-random-gpt2'''   )
													UpperCAmelCase_			:      Tuple     						=  text_generator(__magic_name__   )
													self.assertEqual(
													    __magic_name__       ,     [{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}]       ,     )

													UpperCAmelCase_			:      Optional[Any]     						=  text_generator(__magic_name__       ,     stop_sequence=''' fe'''   )
													self.assertEqual(__magic_name__       ,     [{'''generated_text''': '''Hello I believe in fe'''}]   )

							def     UpperCAmelCase__	(							self							:     Tuple       ,     __magic_name__							:     Union[str, Any]       ,     __magic_name__							:     Tuple   )					->       List[str]:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  text_generator.model
													UpperCAmelCase_			:      Optional[int]     						=  text_generator.tokenizer

													UpperCAmelCase_			:      Any     						=  text_generator('''This is a test'''   )
													self.assertEqual(__magic_name__       ,     [{'''generated_text''': ANY(__magic_name__   )}]   )
													self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''   )   )

													UpperCAmelCase_			:      Optional[int]     						=  text_generator('''This is a test'''       ,     return_full_text=__magic_name__   )
													self.assertEqual(__magic_name__       ,     [{'''generated_text''': ANY(__magic_name__   )}]   )
													self.assertNotIn('''This is a test'''       ,     outputs[0]['''generated_text''']   )

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

													UpperCAmelCase_			:      Optional[int]     						=  text_generator('''This is a test'''       ,     return_full_text=__magic_name__   )
													self.assertEqual(__magic_name__       ,     [{'''generated_text''': ANY(__magic_name__   )}]   )
													self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''   )   )

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

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

													with self.assertRaises(__magic_name__   ):
																			UpperCAmelCase_			:      Union[str, Any]     						=  text_generator('''test'''       ,     return_full_text=__magic_name__       ,     return_text=__magic_name__   )
													with self.assertRaises(__magic_name__   ):
																			UpperCAmelCase_			:      List[str]     						=  text_generator('''test'''       ,     return_full_text=__magic_name__       ,     return_tensors=__magic_name__   )
													with self.assertRaises(__magic_name__   ):
																			UpperCAmelCase_			:      List[Any]     						=  text_generator('''test'''       ,     return_text=__magic_name__       ,     return_tensors=__magic_name__   )

													# 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_			:      Union[str, Any]     						=  text_generator(''''''   )
																			self.assertEqual(__magic_name__       ,     [{'''generated_text''': ANY(__magic_name__   )}]   )
													else:
																			with self.assertRaises((ValueError, AssertionError)   ):
																									UpperCAmelCase_			:      Any     						=  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_			:      Tuple     						=  ['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
													if (
													    tokenizer.model_max_length < 1_00_00
													    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''' * 5_00       ,     max_new_tokens=20   )

																			UpperCAmelCase_			:      int     						=  text_generator('''This is a test''' * 5_00       ,     handle_long_generation='''hole'''       ,     max_new_tokens=20   )
																			# Hole strategy cannot work
																			with self.assertRaises(__magic_name__   ):
																									text_generator(
																									    '''This is a test''' * 5_00       ,     handle_long_generation='''hole'''       ,     max_new_tokens=tokenizer.model_max_length + 10       ,     )

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







													"""simple docstring"""
													import torch

													# Classic `model_kwargs`
													UpperCAmelCase_			:      Union[str, Any]     						=  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_			:      Dict     						=  pipe('''This is a test'''   )
													self.assertEqual(
													    __magic_name__       ,     [
													        {
													            '''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_			:      List[Any]     						=  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_			:      Any     						=  pipe('''This is a test'''   )
													self.assertEqual(
													    __magic_name__       ,     [
													        {
													            '''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_			:      List[Any]     						=  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_			:      Optional[int]     						=  pipe('''This is a test'''   )
													self.assertEqual(
													    __magic_name__       ,     [
													        {
													            '''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							:     List[str]   )					->       Optional[Any]:







													"""simple docstring"""
													import torch

													UpperCAmelCase_			:      Any     						=  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							:     Dict   )					->       Optional[Any]:







													"""simple docstring"""
													import torch

													UpperCAmelCase_			:      Tuple     						=  pipeline(model='''hf-internal-testing/tiny-random-bloom'''       ,     device_map='''auto'''       ,     torch_dtype=torch.floataa   )
													pipe('''This is a test'''       ,     do_sample=__magic_name__       ,     top_p=0.5   )



							def     UpperCAmelCase__	(							self							:     List[Any]   )					->       Any:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  '''Hello world'''
													UpperCAmelCase_			:      Optional[int]     						=  pipeline('''text-generation'''       ,     model='''hf-internal-testing/tiny-random-gpt2'''   )
													if text_generator.model.framework == "tf":
																			UpperCAmelCase_			:      str     						=  logging.get_logger('''transformers.generation.tf_utils'''   )
													else:
																			UpperCAmelCase_			:      Optional[int]     						=  logging.get_logger('''transformers.generation.utils'''   )
													UpperCAmelCase_			:      str     						=  '''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(__magic_name__   ) as cl:
																			UpperCAmelCase_			:      int     						=  text_generator(__magic_name__       ,     max_length=10       ,     max_new_tokens=1   )
													self.assertIn(__magic_name__       ,     cl.out   )

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

													with CaptureLogger(__magic_name__   ) as cl:
																			UpperCAmelCase_			:      Tuple     						=  text_generator(__magic_name__       ,     max_length=10   )
													self.assertNotIn(__magic_name__       ,     cl.out   )












'''simple docstring'''







import sys
import turtle





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float]   ) ->	tuple[float, float]:
						return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			int,			) ->	None:
						my_pen.up()
						my_pen.goto(vertexa[0],			vertexa[1]   )
						my_pen.down()
						my_pen.goto(vertexa[0],			vertexa[1]   )
						my_pen.goto(vertexa[0],			vertexa[1]   )
						my_pen.goto(vertexa[0],			vertexa[1]   )

						if depth == 0:
												return

						triangle(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			depth - 1   )
						triangle(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			depth - 1   )
						triangle(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			depth - 1   )


if __name__ == "__main__":
					if len(sys.argv) != 2:
										raise ValueError(
										    "Correct format for using this script: "
										    "python fractals.py <int:depth_for_fractal>"
										)
					snake_case_     :       Any						=  turtle.Turtle()
					my_pen.ht()
					my_pen.speed(5)
					my_pen.pencolor("red")

					snake_case_     :       Tuple						=  [(-1_75, -1_25), (0, 1_75), (1_75, -1_25)]  # vertices of triangle
					triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))





