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



 '''simple docstring'''




 __A			       =					MODEL_FOR_CAUSAL_LM_MAPPING
 __A			       =					TF_MODEL_FOR_CAUSAL_LM_MAPPING







 @require_torch
 def 		__UpperCAmelCase				(		self				:   Any)						->	Tuple:


   """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=lowercase_)
   self.assertEqual(
       lowercase_							, [
           {
               "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(
       lowercase_							, [
           [
               {
                   "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=lowercase_							, num_return_sequences=2							, return_tensors=lowercase_)
   self.assertEqual(
       lowercase_							, [
           {"generated_token_ids": ANY(lowercase_)},
           {"generated_token_ids": ANY(lowercase_)},
       ]							, )
   _UpperCamelCase           =    text_generator.model.config.eos_token_id
   _UpperCamelCase           =    "<pad>"
   _UpperCamelCase           =    text_generator(
       ["This is a test", "This is a second test"]							, do_sample=lowercase_							, num_return_sequences=2							, batch_size=2							, return_tensors=lowercase_							, )
   self.assertEqual(
       lowercase_							, [
           [
               {"generated_token_ids": ANY(lowercase_)},
               {"generated_token_ids": ANY(lowercase_)},
           ],
           [
               {"generated_token_ids": ANY(lowercase_)},
               {"generated_token_ids": ANY(lowercase_)},
           ],
       ]							, )







 @require_tf
 def 		__UpperCAmelCase				(		self				:   Union[str, Any])						->	Union[str, Any]:


   """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=lowercase_)
   self.assertEqual(
       lowercase_							, [
           {
               "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=lowercase_)
   self.assertEqual(
       lowercase_							, [
           [
               {
                   "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				:   List[str]							, lowercase_				:   Any							, lowercase_				:   Optional[Any]							, lowercase_				:   int)						->	str:


   """simple docstring"""







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







 def 		__UpperCAmelCase				(		self				:   Optional[int])						->	str:


   """simple docstring"""







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

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







 def 		__UpperCAmelCase				(		self				:   int							, lowercase_				:   str							, lowercase_				:   int)						->	List[str]:


   """simple docstring"""







   _UpperCamelCase           =    text_generator.model
   _UpperCamelCase           =    text_generator.tokenizer

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

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

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

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

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

   with self.assertRaises(lowercase_):
     _UpperCamelCase           =    text_generator("test"							, return_full_text=lowercase_							, return_text=lowercase_)
   with self.assertRaises(lowercase_):
     _UpperCamelCase           =    text_generator("test"							, return_full_text=lowercase_							, return_tensors=lowercase_)
   with self.assertRaises(lowercase_):
     _UpperCamelCase           =    text_generator("test"							, return_text=lowercase_							, return_tensors=lowercase_)

   # 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(lowercase_							, [{"generated_text": ANY(lowercase_)}])
   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(lowercase_):
       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 		__UpperCAmelCase				(		self				:   Optional[int])						->	Optional[int]:


   """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(
       lowercase_							, [
           {
               "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(
       lowercase_							, [
           {
               "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(
       lowercase_							, [
           {
               "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				:   Optional[int])						->	List[str]:


   """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 		__UpperCAmelCase				(		self				:   List[str])						->	str:


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







 def 		__UpperCAmelCase				(		self				:   int)						->	Union[str, Any]:


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

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

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





from math import isqrt, loga


def 				lowerCAmelCase__       (			a__ )      ->list[int]:




  '''simple docstring'''

  _UpperCamelCase           =    [True] * max_number
  for i in range(2    ,     isqrt(max_number - 1 ) + 1 ):
    if is_prime[i]:
      for j in range(i**2    ,     a__    ,     a__ ):
        _UpperCamelCase           =    False

  return [i for i in range(2    ,     a__ ) if is_prime[i]]


def 				lowerCAmelCase__       (			a__ = 800_800    ,     a__ = 800_800 )      ->int:




  '''simple docstring'''

  _UpperCamelCase           =    degree * loga(a__ )
  _UpperCamelCase           =    int(a__ )
  _UpperCamelCase           =    calculate_prime_numbers(a__ )

  _UpperCamelCase           =    0
  _UpperCamelCase           =    0
  _UpperCamelCase           =    len(a__ ) - 1
  while left < right:
    while (
        prime_numbers[right] * loga(prime_numbers[left] )
        + prime_numbers[left] * loga(prime_numbers[right] )
        > upper_bound
    ):
      right -= 1
    hybrid_integers_count += right - left
    left += 1

  return hybrid_integers_count


if __name__ == "__main__":
   print(F"{solution() = }")




