


'''simple docstring'''



import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


if is_flax_available():
	import jax
	import jax.numpy as jnp





@slow
@require_flax
class 							__UpperCamelCase    (		unittest.TestCase ):




	def 				__UpperCAmelCase							(       self						,    __a						,    __a							):

						'''simple docstring'''





						return f"""gaussian_noise_s={seed}_shape={"_".join([str(__a							) for s in shape]							)}.npy"""




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						super().tearDown()
						gc.collect()




	def 				__UpperCAmelCase							(       self						,    __a=0						,    __a=(4, 4, 64, 64)						,    __a=False							):

						'''simple docstring'''





						__a      :	Optional[Any]    =  jnp.bfloataa if fpaa else jnp.floataa
						__a      :	Tuple    =  jnp.array(load_hf_numpy(self.get_file_format(__a						,    __a							)							)						,    dtype=__a							)
						return image




	def 				__UpperCAmelCase							(       self						,    __a=False						,    __a="CompVis/stable-diffusion-v1-4"							):

						'''simple docstring'''





						__a      :	List[str]    =  jnp.bfloataa if fpaa else jnp.floataa
						__a      :	str    =  'bf16' if fpaa else None

						__a   ,    __a      :	Optional[Any]    =  FlaxUNetaDConditionModel.from_pretrained(
						    __a						,    subfolder='unet'						,    dtype=__a						,    revision=__a							)
						return model, params




	def 				__UpperCAmelCase							(       self						,    __a=0						,    __a=(4, 77, 768)						,    __a=False							):

						'''simple docstring'''





						__a      :	Dict    =  jnp.bfloataa if fpaa else jnp.floataa
						__a      :	Optional[int]    =  jnp.array(load_hf_numpy(self.get_file_format(__a						,    __a							)							)						,    dtype=__a							)
						return hidden_states




	@parameterized.expand(
	    [
	        # fmt: off
	        [83, 4, [-0.2323, -0.1304, 0.0813, -0.3093, -0.0919, -0.1571, -0.1125, -0.5806]],
	        [17, 0.55, [-0.0831, -0.2443, 0.0901, -0.0919, 0.3396, 0.0103, -0.3743, 0.0701]],
	        [8, 0.89, [-0.4863, 0.0859, 0.0875, -0.1658, 0.9199, -0.0114, 0.4839, 0.4639]],
	        [3, 1000, [-0.5649, 0.2402, -0.5518, 0.1248, 1.1328, -0.2443, -0.0325, -1.0078]],
	        # fmt: on
	    ]							)
	def 				__UpperCAmelCase							(       self						,    __a						,    __a						,    __a							):

						'''simple docstring'''





						__a   ,    __a      :	Optional[int]    =  self.get_unet_model(model_id='CompVis/stable-diffusion-v1-4'						,    fpaa=__a							)
						__a      :	Any    =  self.get_latents(__a						,    fpaa=__a							)
						__a      :	Dict    =  self.get_encoder_hidden_states(__a						,    fpaa=__a							)

						__a      :	Optional[int]    =  model.apply(
						    {'params': params}						,    __a						,    jnp.array(__a						,    dtype=jnp.intaa							)						,    encoder_hidden_states=__a						,    ).sample

						assert sample.shape == latents.shape

						__a      :	Optional[Any]    =  jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())							)						,    dtype=jnp.floataa							)
						__a      :	Any    =  jnp.array(__a						,    dtype=jnp.floataa							)

						# Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
						assert jnp.allclose(__a						,    __a						,    atol=1E-2							)





	@parameterized.expand(
	    [
	        # fmt: off
	        [83, 4, [0.1514, 0.0807, 0.1624, 0.1016, -0.1896, 0.0263, 0.0677, 0.2310]],
	        [17, 0.55, [0.1164, -0.0216, 0.0170, 0.1589, -0.3120, 0.1005, -0.0581, -0.1458]],
	        [8, 0.89, [-0.1758, -0.0169, 0.1004, -0.1411, 0.1312, 0.1103, -0.1996, 0.2139]],
	        [3, 1000, [0.1214, 0.0352, -0.0731, -0.1562, -0.0994, -0.0906, -0.2340, -0.0539]],
	        # fmt: on
	    ]							)
	def 				__UpperCAmelCase							(       self						,    __a						,    __a						,    __a							):

						'''simple docstring'''





						__a   ,    __a      :	int    =  self.get_unet_model(model_id='stabilityai/stable-diffusion-2'						,    fpaa=__a							)
						__a      :	int    =  self.get_latents(__a						,    shape=(4, 4, 96, 96)						,    fpaa=__a							)
						__a      :	Optional[Any]    =  self.get_encoder_hidden_states(__a						,    shape=(4, 77, 1024)						,    fpaa=__a							)

						__a      :	Optional[Any]    =  model.apply(
						    {'params': params}						,    __a						,    jnp.array(__a						,    dtype=jnp.intaa							)						,    encoder_hidden_states=__a						,    ).sample

						assert sample.shape == latents.shape

						__a      :	Optional[Any]    =  jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())							)						,    dtype=jnp.floataa							)
						__a      :	Optional[int]    =  jnp.array(__a						,    dtype=jnp.floataa							)

						# Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
						assert jnp.allclose(__a						,    __a						,    atol=1E-2							)







'''simple docstring'''



import json
import os
import re
import sys
import urllib.request

import requests
from bsa import BeautifulSoup

__lowercase     :						str	=     {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    ' (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19582'
}






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       str = "dhaka"						,				_SCREAMING_SNAKE_CASE				:       int = 5       ):
					__a      :	Optional[Any]    =  min(_SCREAMING_SNAKE_CASE						,				50       )  # Prevent abuse!
					__a      :	Optional[Any]    =  {
					    'q': query,
					    'tbm': 'isch',
					    'hl': 'en',
					    'ijn': '0',
					}

					__a      :	Tuple    =  requests.get('https://www.google.com/search'						,				params=_SCREAMING_SNAKE_CASE						,				headers=_SCREAMING_SNAKE_CASE       )
					__a      :	Dict    =  BeautifulSoup(html.text						,				'html.parser'       )
					__a      :	List[str]    =  ''.join(
					    re.findall(r'AF_initDataCallback\(([^<]+)\);'						,				str(soup.select('script'       )       )       )       )

					__a      :	Optional[Any]    =  json.dumps(_SCREAMING_SNAKE_CASE       )
					__a      :	List[str]    =  json.loads(_SCREAMING_SNAKE_CASE       )

					__a      :	List[Any]    =  re.findall(
					    r'\[\"GRID_STATE0\",null,\[\[1,\[0,\".*?\",(.*),\"All\",'						,				_SCREAMING_SNAKE_CASE						,				)
					if not matched_google_image_data:
										return 0

					__a      :	Tuple    =  re.sub(
					    r'\[\"(https\:\/\/encrypted-tbn0\.gstatic\.com\/images\?.*?)\",\d+,\d+\]'						,				''						,				str(_SCREAMING_SNAKE_CASE       )						,				)

					__a      :	Optional[Any]    =  re.findall(
					    r'(?:\'|,),\[\"(https:|http.*?)\",\d+,\d+\]'						,				_SCREAMING_SNAKE_CASE						,				)
					for index, fixed_full_res_image in enumerate(_SCREAMING_SNAKE_CASE       ):
										if index >= max_images:
															return index
										__a      :	List[str]    =  bytes(_SCREAMING_SNAKE_CASE						,				'ascii'       ).decode(
										    'unicode-escape'       )
										__a      :	Tuple    =  bytes(_SCREAMING_SNAKE_CASE						,				'ascii'       ).decode(
										    'unicode-escape'       )
										__a      :	Dict    =  urllib.request.build_opener()
										__a      :	Union[str, Any]    =  [
										    (
										        'User-Agent',
										        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
										        ' (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19582',
										    )
										]
										urllib.request.install_opener(_SCREAMING_SNAKE_CASE       )
										__a      :	List[Any]    =  F"""query_{query.replace(" "						,				"_"       )}"""
										if not os.path.exists(_SCREAMING_SNAKE_CASE       ):
															os.makedirs(_SCREAMING_SNAKE_CASE       )
										urllib.request.urlretrieve(  # noqa: S310
										    _SCREAMING_SNAKE_CASE						,				F"""{path_name}/original_size_img_{index}.jpg"""       )
					return index


if __name__ == "__main__":
	try:
		__lowercase     :						Optional[int]	=     download_images_from_google_query(sys.argv[1])
		print(f'''{image_count} images were downloaded to disk.''')
	except IndexError:
		print('Please provide a search term.')
		raise



