
'''simple docstring'''
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()






class      snake_case__    (	unittest.TestCase ):







		"""simple docstring"""

		@property
		def 	lowerCAmelCase							(	self							:       Tuple	)		->       Optional[Any]:






				"""simple docstring"""







				snake_case   :    List[str]			       =		1
				snake_case   :    Any			       =		3
				snake_case   :    List[str]			       =		(32, 32)

				snake_case   :    Optional[Any]			       =		floats_tensor((batch_size, num_channels) + sizes   ,     rng=random.Random(0	)	).to(UpperCamelCase__	)
				return image



		@property
		def 	lowerCAmelCase							(	self							:       int	)		->       Tuple:






				"""simple docstring"""







				torch.manual_seed(0	)
				snake_case   :    Any			       =		UNetaDModel(
				    block_out_channels=(32, 64)   ,     layers_per_block=2   ,     sample_size=32   ,     in_channels=6   ,     out_channels=3   ,     down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')   ,     up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')   ,     )
				return model



		@property
		def 	lowerCAmelCase							(	self							:       Optional[int]	)		->       Optional[int]:






				"""simple docstring"""







				torch.manual_seed(0	)
				snake_case   :    Optional[int]			       =		VQModel(
				    block_out_channels=[32, 64]   ,     in_channels=3   ,     out_channels=3   ,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,     latent_channels=3   ,     )
				return model



		def 	lowerCAmelCase							(	self							:       Tuple	)		->       Dict:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		'''cpu'''
				snake_case   :    Any			       =		self.dummy_uncond_unet
				snake_case   :    List[Any]			       =		DDIMScheduler()
				snake_case   :    str			       =		self.dummy_vq_model

				snake_case   :    Tuple			       =		LDMSuperResolutionPipeline(unet=UpperCamelCase__   ,     vqvae=UpperCamelCase__   ,     scheduler=UpperCamelCase__	)
				ldm.to(UpperCamelCase__	)
				ldm.set_progress_bar_config(disable=UpperCamelCase__	)

				snake_case   :    Optional[int]			       =		self.dummy_image.to(UpperCamelCase__	)

				snake_case   :    List[Any]			       =		torch.Generator(device=UpperCamelCase__	).manual_seed(0	)
				snake_case   :    List[str]			       =		ldm(image=UpperCamelCase__   ,     generator=UpperCamelCase__   ,     num_inference_steps=2   ,     output_type='''numpy'''	).images

				snake_case   :    List[str]			       =		image[0, -3:, -3:, -1]

				assert image.shape == (1, 64, 64, 3)
				snake_case   :    List[Any]			       =		np.array([0.8_678, 0.8_245, 0.6_381, 0.6_830, 0.4_385, 0.5_599, 0.4_641, 0.6_201, 0.5_150]	)

				assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2



		@unittest.skipIf(torch_device != '''cuda'''   ,     '''This test requires a GPU'''	)
		def 	lowerCAmelCase							(	self							:       str	)		->       int:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		self.dummy_uncond_unet
				snake_case   :    Optional[Any]			       =		DDIMScheduler()
				snake_case   :    int			       =		self.dummy_vq_model

				# put models in fp16
				snake_case   :    List[str]			       =		unet.half()
				snake_case   :    Optional[int]			       =		vqvae.half()

				snake_case   :    List[str]			       =		LDMSuperResolutionPipeline(unet=UpperCamelCase__   ,     vqvae=UpperCamelCase__   ,     scheduler=UpperCamelCase__	)
				ldm.to(UpperCamelCase__	)
				ldm.set_progress_bar_config(disable=UpperCamelCase__	)

				snake_case   :    Optional[Any]			       =		self.dummy_image.to(UpperCamelCase__	)

				snake_case   :    Tuple			       =		ldm(UpperCamelCase__   ,     num_inference_steps=2   ,     output_type='''numpy'''	).images

				assert image.shape == (1, 64, 64, 3)







@slow
@require_torch
class      snake_case__    (	unittest.TestCase ):







		"""simple docstring"""

		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       Optional[int]:






				"""simple docstring"""







				snake_case   :    Union[str, Any]			       =		load_image(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
				    '''/vq_diffusion/teddy_bear_pool.png'''	)
				snake_case   :    Dict			       =		init_image.resize((64, 64)   ,     resample=PIL_INTERPOLATION['''lanczos''']	)

				snake_case   :    int			       =		LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution'''   ,     device_map='''auto'''	)
				ldm.set_progress_bar_config(disable=UpperCamelCase__	)

				snake_case   :    Dict			       =		torch.manual_seed(0	)
				snake_case   :    List[Any]			       =		ldm(image=UpperCamelCase__   ,     generator=UpperCamelCase__   ,     num_inference_steps=20   ,     output_type='''numpy'''	).images

				snake_case   :    List[Any]			       =		image[0, -3:, -3:, -1]

				assert image.shape == (1, 256, 256, 3)
				snake_case   :    Optional[int]			       =		np.array([0.7_644, 0.7_679, 0.7_642, 0.7_633, 0.7_666, 0.7_560, 0.7_425, 0.7_257, 0.6_907]	)

				assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2




'''simple docstring'''
import bsa
import requests




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__       )   ->				dict[str, str]:


		'''simple docstring'''


		return {
		    "name": soup.ha.a.text,
		    "genre": soup.find('''span'''      ,    class_='''genre'''       ).text.strip(),
		    "rating": soup.strong.text,
		    "page_link": F'https://www.imdb.com{soup.a.get("href"       )}',
		}




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__ = 5       )   ->				tuple:


		'''simple docstring'''


		snake_case   :    List[Any]			       =		int(float(SCREAMING_SNAKE_CASE__       )       )
		if num_movies < 1:
				return ()
		snake_case   :    int			       =		(
		    '''https://www.imdb.com/search/title?title_type='''
		    F'feature&sort=num_votes,desc&count={num_movies}'
		)
		snake_case   :    Optional[Any]			       =		bsa.BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE__       ).content      ,    '''html.parser'''       )
		return tuple(
		    get_movie_data_from_soup(SCREAMING_SNAKE_CASE__       )
		    for movie in source.find_all('''div'''      ,    class_='''lister-item mode-advanced'''       )       )


if __name__ == "__main__":
						import json

						lowercase__		    =	int(input("How many movies would you like to see? "))
						print(
						    ", ".join(
						        json.dumps(movie, indent=4) for movie in get_imdb_top_movies(num_movies)
						    )
						)


