
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   __lowercase						(						unittest.TestCase       ):
	_A       =   MODEL_FOR_CAUSAL_LM_MAPPING
	_A       =   TF_MODEL_FOR_CAUSAL_LM_MAPPING






	@require_torch
	def       _a(self				: Optional[int]    ) ->			str:
							_lowercase       :	List[str]           =   pipeline(task="text-generation"      ,	model="sshleifer/tiny-ctrl"      ,	framework="pt"    )
							# Using `do_sample=False` to force deterministic output
							_lowercase       :	int           =   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@@"
							            )
							        }
							    ]      ,	)

							_lowercase       :	Tuple           =   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@@"
							                )
							            }
							        ],
							    ]      ,	)

							_lowercase       :	Any           =   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    )},
							    ]      ,	)
							_lowercase       :	List[Any]           =   text_generator.model.config.eos_token_id
							_lowercase       :	Any           =   "<pad>"
							_lowercase       :	Optional[Any]           =   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       _a(self				: int    ) ->			Any:
							_lowercase       :	List[Any]           =   pipeline(task="text-generation"      ,	model="sshleifer/tiny-ctrl"      ,	framework="tf"    )

							# Using `do_sample=False` to force deterministic output
							_lowercase       :	Union[str, Any]           =   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,"
							            )
							        }
							    ]      ,	)

							_lowercase       :	Dict           =   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       _a(self				: int      ,	snake_case				: Optional[Any]      ,	snake_case				: Tuple      ,	snake_case				: Dict    ) ->			List[str]:
							_lowercase       :	str           =   TextGenerationPipeline(model=snake_case      ,	tokenizer=snake_case    )
							return text_generator, ["This is a test", "Another test"]






	def       _a(self				: Union[str, Any]    ) ->			Optional[Any]:
							_lowercase       :	Dict           =   "Hello I believe in"
							_lowercase       :	Any           =   pipeline("text-generation"      ,	model="hf-internal-testing/tiny-random-gpt2"    )
							_lowercase       :	Dict           =   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"}]      ,	)

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






	def       _a(self				: Dict      ,	snake_case				: Union[str, Any]      ,	snake_case				: Any    ) ->			str:
							_lowercase       :	List[str]           =   text_generator.model
							_lowercase       :	List[str]           =   text_generator.tokenizer

							_lowercase       :	Any           =   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"    )    )

							_lowercase       :	List[str]           =   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"]    )

							_lowercase       :	int           =   pipeline(task="text-generation"      ,	model=snake_case      ,	tokenizer=snake_case      ,	return_full_text=snake_case    )
							_lowercase       :	Any           =   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"]    )

							_lowercase       :	Optional[Any]           =   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"    )    )

							_lowercase       :	str           =   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:
													_lowercase       :	Dict           =   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    ):
													_lowercase       :	List[Any]           =   text_generator("test"      ,	return_full_text=snake_case      ,	return_text=snake_case    )
							with self.assertRaises(snake_case    ):
													_lowercase       :	Any           =   text_generator("test"      ,	return_full_text=snake_case      ,	return_tensors=snake_case    )
							with self.assertRaises(snake_case    ):
													_lowercase       :	Optional[int]           =   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__
							):
													_lowercase       :	Optional[int]           =   text_generator(""    )
													self.assertEqual(snake_case      ,	[{"generated_text": ANY(snake_case    )}]    )
							else:
													with self.assertRaises((ValueError, AssertionError)    ):
																			_lowercase       :	str           =   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.
							_lowercase       :	Optional[Any]           =   ["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    )

													_lowercase       :	List[str]           =   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       _a(self				: Dict    ) ->			List[str]:
							import torch

							# Classic `model_kwargs`
							_lowercase       :	int           =   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    )
							_lowercase       :	Optional[int]           =   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.)
							_lowercase       :	Optional[int]           =   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    )
							_lowercase       :	Union[str, Any]           =   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
							_lowercase       :	List[str]           =   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    )
							_lowercase       :	str           =   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       _a(self				: Union[str, Any]    ) ->			Optional[int]:
							import torch

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

							_lowercase       :	Optional[Any]           =   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       _a(self				: Dict    ) ->			Any:
							_lowercase       :	List[str]           =   "Hello world"
							_lowercase       :	Union[str, Any]           =   pipeline("text-generation"      ,	model="hf-internal-testing/tiny-random-gpt2"    )
							if text_generator.model.framework == "tf":
													_lowercase       :	Union[str, Any]           =   logging.get_logger("transformers.generation.tf_utils"    )
							else:
													_lowercase       :	str           =   logging.get_logger("transformers.generation.utils"    )
							_lowercase       :	Any           =   "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:
													_lowercase       :	int           =   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:
													_lowercase       :	Optional[int]           =   text_generator(snake_case      ,	max_new_tokens=1    )
							self.assertNotIn(snake_case      ,	cl.out    )

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






import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

UpperCamelCase_						:     List[Any]	       =							3



def 		UpperCamelCase     (       _UpperCAmelCase  :   int  )   ->			int:






						'''simple docstring'''

						print("Generating primitive root of p"  )
						while True:
												_lowercase       :	Any           =   random.randrange(3 ,			_UpperCAmelCase  )
												if pow(_UpperCAmelCase ,			2 ,			_UpperCAmelCase  ) == 1:
																		continue
												if pow(_UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase  ) == 1:
																		continue
												return g



def 		UpperCamelCase     (       _UpperCAmelCase  :   int  )   ->			tuple[tuple[int, int, int, int], tuple[int, int]]:






						'''simple docstring'''

						print("Generating prime p..."  )
						_lowercase       :	Optional[int]           =   rabin_miller.generate_large_prime(_UpperCAmelCase  )  # select large prime number.
						_lowercase       :	Dict           =   primitive_root(_UpperCAmelCase  )  # one primitive root on modulo p.
						_lowercase       :	Any           =   random.randrange(3 ,			_UpperCAmelCase  )  # private_key -> have to be greater than 2 for safety.
						_lowercase       :	Tuple           =   cryptomath.find_mod_inverse(pow(_UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase  ) ,			_UpperCAmelCase  )

						_lowercase       :	List[Any]           =   (key_size, e_a, e_a, p)
						_lowercase       :	Union[str, Any]           =   (key_size, d)

						return public_key, private_key



def 		UpperCamelCase     (       _UpperCAmelCase  :   str ,			_UpperCAmelCase  :   int  )   ->			None:






						'''simple docstring'''

						if os.path.exists(f"""{name}_pubkey.txt"""  ) or os.path.exists(f"""{name}_privkey.txt"""  ):
												print("\nWARNING:"  )
												print(
												    f"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
												    "Use a different name or delete these files and re-run this program."  )
												sys.exit()

						_lowercase      ,    _lowercase       :	Optional[Any]           =   generate_key(_UpperCAmelCase  )
						print(f"""\nWriting public key to file {name}_pubkey.txt..."""  )
						with open(f"""{name}_pubkey.txt""" ,			"w"  ) as fo:
												fo.write(f"""{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}"""  )

						print(f"""Writing private key to file {name}_privkey.txt..."""  )
						with open(f"""{name}_privkey.txt""" ,			"w"  ) as fo:
												fo.write(f"""{private_key[0]},{private_key[1]}"""  )



def 		UpperCamelCase     (       )   ->			None:






						'''simple docstring'''

						print("Making key files..."  )
						make_key_files("elgamal" ,			2048  )
						print("Key files generation successful"  )


if __name__ == "__main__":
							main()




