




import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()





class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE			,  _SCREAMING_SNAKE_CASE			,  unittest.TestCase   ):


 '''simple docstring'''







 lowercase_							       =       VQModel
 lowercase_							       =       "sample"



 @property
 def  lowerCAmelCase_    (				self    :						Dict							,							_lowerCAmelCase    :						str=(32, 32)		):
       SCREAMING_SNAKE_CASE_      		=     4
       SCREAMING_SNAKE_CASE_      		=     3

       SCREAMING_SNAKE_CASE_      		=     floats_tensor((batch_size, num_channels) + sizes		).to(_lowerCAmelCase		)

       return {"sample": image}



 @property
 def  lowerCAmelCase_    (				self    :						str		):
       return (3, 32, 32)



 @property
 def  lowerCAmelCase_    (				self    :						List[str]		):
       return (3, 32, 32)



 def  lowerCAmelCase_    (				self    :						Optional[Any]		):
       SCREAMING_SNAKE_CASE_      		=     {
           'block_out_channels': [32, 64],
           'in_channels': 3,
           'out_channels': 3,
           'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
           'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
           'latent_channels': 3,
       }
       SCREAMING_SNAKE_CASE_      		=     self.dummy_input
       return init_dict, inputs_dict



 def  lowerCAmelCase_    (				self    :						Tuple		):
       pass



 def  lowerCAmelCase_    (				self    :						List[str]		):
       pass



 def  lowerCAmelCase_    (				self    :						List[Any]		):
       SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_      		=     VQModel.from_pretrained('fusing/vqgan-dummy'							,							output_loading_info=_lowerCAmelCase		)
       self.assertIsNotNone(_lowerCAmelCase		)
       self.assertEqual(len(loading_info['missing_keys']		)							,							0		)

       model.to(_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     model(**self.dummy_input		)

       assert image is not None, "Make sure output is not None"




 def  lowerCAmelCase_    (				self    :						List[Any]		):
       SCREAMING_SNAKE_CASE_      		=     VQModel.from_pretrained('fusing/vqgan-dummy'		)
       model.to(_lowerCAmelCase		).eval()

       torch.manual_seed(0		)
       if torch.cuda.is_available():
             torch.cuda.manual_seed_all(0		)

       SCREAMING_SNAKE_CASE_      		=     torch.randn(1							,							model.config.in_channels							,							model.config.sample_size							,							model.config.sample_size		)
       SCREAMING_SNAKE_CASE_      		=     image.to(_lowerCAmelCase		)
       with torch.no_grad():
             SCREAMING_SNAKE_CASE_      		=     model(_lowerCAmelCase		).sample

       SCREAMING_SNAKE_CASE_      		=     output[0, -1, -3:, -3:].flatten().cpu()
       # fmt: off
       SCREAMING_SNAKE_CASE_      		=     torch.tensor([-0.0153, -0.4044, -0.1880, -0.5161, -0.2418, -0.4072, -0.1612, -0.0633, -0.0143]		)
       # fmt: on
       self.assertTrue(torch.allclose(_lowerCAmelCase							,							_lowerCAmelCase							,							atol=1E-3		)		)





from __future__ import annotations

from collections.abc import Generator

def    UpperCAmelCase_				( )   ->					Generator[int, None, None]:
      SCREAMING_SNAKE_CASE_      		=     {}
      SCREAMING_SNAKE_CASE_      		=     2
      while True:
            SCREAMING_SNAKE_CASE_      		=     factor_map.pop(__UpperCAmelCase     ,     __UpperCAmelCase				)
            if factor:
                  SCREAMING_SNAKE_CASE_      		=     factor + prime
                  while x in factor_map:
                        x += factor
                  SCREAMING_SNAKE_CASE_      		=     factor
            else:
                  SCREAMING_SNAKE_CASE_      		=     prime
                  yield prime
            prime += 1

def    UpperCAmelCase_				( __UpperCAmelCase		:      float = 1E10				)   ->					int:
      SCREAMING_SNAKE_CASE_      		=     sieve()

      SCREAMING_SNAKE_CASE_      		=     1
      while True:
            SCREAMING_SNAKE_CASE_      		=     next(__UpperCAmelCase				)
            if (2 * prime * n) > limit:
                  return n
            # Ignore the next prime as the reminder will be 2.
            next(__UpperCAmelCase				)
            n += 2


if __name__ == "__main__":
   print(solution())