


'''simple docstring'''


import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class        __magic_name__  (					lowerCAmelCase						,		lowerCAmelCase						,		unittest.TestCase   ):

     """simple docstring"""






     lowerCamelCase__						=							IFImgaImgPipeline
     lowerCamelCase__						=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     lowerCamelCase__						=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCamelCase__						=							PipelineTesterMixin.required_optional_params - {'latents'}


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          return self._get_dummy_components()


     def lowerCAmelCase__     (      self ,    lowerCamelCase ,    lowerCamelCase=0		):


          '''simple docstring'''





          if str(lowerCamelCase		).startswith("mps"		):
               __A  :					Optional[Any]						     =       torch.manual_seed(lowerCamelCase		)
          else:
               __A  :					Union[str, Any]						     =       torch.Generator(device=lowerCamelCase		).manual_seed(lowerCamelCase		)

          __A  :					Any						     =       floats_tensor((1, 3, 32, 32) ,    rng=random.Random(lowerCamelCase		)		).to(lowerCamelCase		)

          __A  :					Any						     =       {
              "prompt": "A painting of a squirrel eating a burger",
              "image": image,
              "generator": generator,
              "num_inference_steps": 2,
              "output_type": "numpy",
          }

          return inputs


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          self._test_save_load_optional_components()


     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available() ,    reason="XFormers attention is only available with CUDA and `xformers` installed" ,    )
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)


     @unittest.skipIf(torch_device != "cuda" ,    reason="float16 requires CUDA"		)
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          super().test_save_load_floataa(expected_max_diff=1E-1		)


     @unittest.skipIf(torch_device != "cuda" ,    reason="float16 requires CUDA"		)
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          super().test_floataa_inference(expected_max_diff=1E-1		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          self._test_save_load_local()


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2 ,    )





'''simple docstring'''


import math
from collections.abc import Generator


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)       ))
     for i in (n for n in numbers if n > 1):
          for j in range(2					,				SCREAMING_SNAKE_CASE       ):
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)       ))
     for i in (n for n in numbers if n > 1):
          # only need to check for factors up to sqrt(i)
          __A  :					Optional[Any]						     =       int(math.sqrt(SCREAMING_SNAKE_CASE       )       ) + 1
          for j in range(2					,				SCREAMING_SNAKE_CASE       ):
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)					,				2       ))
     # It's useless to test even numbers as they will not be prime
     if max_n > 2:
          yield 2  # Because 2 will not be tested, it's necessary to yield it now
     for i in (n for n in numbers if n > 1):
          __A  :					List[str]						     =       int(math.sqrt(SCREAMING_SNAKE_CASE       )       ) + 1
          for j in range(3					,				SCREAMING_SNAKE_CASE					,				2       ):
               # As we removed the even numbers, we don't need them now
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   ():




     '''simple docstring'''





     from timeit import timeit

     __A  :					List[str]						     =       "from __main__ import slow_primes, primes, fast_primes"
     print(timeit("slow_primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )
     print(timeit("primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )
     print(timeit("fast_primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )


if __name__ == "__main__":
      _UpperCamelCase          =     int(input("""Calculate primes up to:\n>> """).strip())
      for ret in primes(number):
            print(ret)
      benchmark()

