



import os
import tempfile
import unittest

import numpy as np

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


if is_flax_available():
				import jax
				import jax.numpy as jnp
				from flax.jax_utils import replicate
				from flax.training.common_utils import shard

				from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline






@require_flax
class 						__a (     unittest.TestCase				):



	def 		UpperCamelCase							(						self							:    Tuple)->							List[str]:
						with tempfile.TemporaryDirectory() as tmpdirname:
											# pipeline has Flax weights
											__lowerCAmelCase	   =FlaxDiffusionPipeline.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-pipe"""				,	safety_checker=snake_case_				,	cache_dir=snake_case_)

											__lowerCAmelCase	   =[t[-1] for t in os.walk(os.path.join(snake_case_				,	os.listdir(snake_case_)[0]				,	"""snapshots"""))]
											__lowerCAmelCase	   =[item for sublist in all_root_files for item in sublist]

											# None of the downloaded files should be a PyTorch file even if we have some here:
											# https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
											assert not any(f.endswith(""".bin""") for f in files)






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



	def 		UpperCamelCase							(						self							:    Tuple)->							int:
						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """hf-internal-testing/tiny-stable-diffusion-pipe"""				,	safety_checker=snake_case_)

						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.random.PRNGKey(0)
						__lowerCAmelCase	   =4

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)

						# shard inputs and rng
						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =jax.random.split(snake_case_				,	snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)

						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images

						assert images.shape == (num_samples, 1, 64, 64, 3)
						if jax.device_count() == 8:
											assert np.abs(np.abs(images[0, 0, :2, :2, -2:]				,	dtype=np.floataa).sum() - 4.1_5_1_4_7_4_5) < 1e-3
											assert np.abs(np.abs(snake_case_				,	dtype=np.floataa).sum() - 4_9_9_4_7.8_7_5) < 5e-1

						__lowerCAmelCase	   =pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:])))
						assert len(snake_case_) == num_samples



	def 		UpperCamelCase							(						self							:    List[Any])->							Tuple:
						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""flax"""				,	safety_checker=snake_case_)

						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.random.PRNGKey(0)
						__lowerCAmelCase	   =50

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)

						# shard inputs and rng
						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =jax.random.split(snake_case_				,	snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)

						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images

						assert images.shape == (num_samples, 1, 5_12, 5_12, 3)
						if jax.device_count() == 8:
											assert np.abs((np.abs(images[0, 0, :2, :2, -2:]				,	dtype=np.floataa).sum() - 0.0_5_6_5_2_4_0_1)) < 1e-3
											assert np.abs((np.abs(snake_case_				,	dtype=np.floataa).sum() - 2_3_8_3_8_0_8.2)) < 5e-1



	def 		UpperCamelCase							(						self							:    Dict)->							Union[str, Any]:
						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""bf16"""				,	dtype=jnp.bfloataa				,	safety_checker=snake_case_)

						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.random.PRNGKey(0)
						__lowerCAmelCase	   =50

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)

						# shard inputs and rng
						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =jax.random.split(snake_case_				,	snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)

						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images

						assert images.shape == (num_samples, 1, 5_12, 5_12, 3)
						if jax.device_count() == 8:
											assert np.abs((np.abs(images[0, 0, :2, :2, -2:]				,	dtype=np.floataa).sum() - 0.0_4_0_0_3_9_0_6)) < 1e-3
											assert np.abs((np.abs(snake_case_				,	dtype=np.floataa).sum() - 2_3_7_3_5_1_6.7_5)) < 5e-1



	def 		UpperCamelCase							(						self							:    Optional[int])->							Optional[int]:
						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""bf16"""				,	dtype=jnp.bfloataa)

						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.random.PRNGKey(0)
						__lowerCAmelCase	   =50

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)

						# shard inputs and rng
						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =jax.random.split(snake_case_				,	snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)

						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images

						assert images.shape == (num_samples, 1, 5_12, 5_12, 3)
						if jax.device_count() == 8:
											assert np.abs((np.abs(images[0, 0, :2, :2, -2:]				,	dtype=np.floataa).sum() - 0.0_4_0_0_3_9_0_6)) < 1e-3
											assert np.abs((np.abs(snake_case_				,	dtype=np.floataa).sum() - 2_3_7_3_5_1_6.7_5)) < 5e-1



	def 		UpperCamelCase							(						self							:    List[Any])->							Dict:
						__lowerCAmelCase	   =FlaxDDIMScheduler(
						    beta_start=0.0_0_0_8_5				,	beta_end=0.0_1_2				,	beta_schedule="""scaled_linear"""				,	set_alpha_to_one=snake_case_				,	steps_offset=1				,	)

						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""bf16"""				,	dtype=jnp.bfloataa				,	scheduler=snake_case_				,	safety_checker=snake_case_				,	)
						__lowerCAmelCase	   =scheduler.create_state()

						__lowerCAmelCase	   =scheduler_state

						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.random.PRNGKey(0)
						__lowerCAmelCase	   =50

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)

						# shard inputs and rng
						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =jax.random.split(snake_case_				,	snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)

						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images

						assert images.shape == (num_samples, 1, 5_12, 5_12, 3)
						if jax.device_count() == 8:
											assert np.abs((np.abs(images[0, 0, :2, :2, -2:]				,	dtype=np.floataa).sum() - 0.0_4_5_0_4_3_9_4_5)) < 1e-3
											assert np.abs((np.abs(snake_case_				,	dtype=np.floataa).sum() - 2_3_4_7_6_9_3.5)) < 5e-1



	def 		UpperCamelCase							(						self							:    List[Any])->							Dict:
						__lowerCAmelCase	   =(
						    """A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"""
						    """ field, close up, split lighting, cinematic"""
						)

						__lowerCAmelCase	   =jax.device_count()
						__lowerCAmelCase	   =num_samples * [prompt]
						__lowerCAmelCase	   =jax.random.split(jax.random.PRNGKey(0)				,	snake_case_)

						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""bf16"""				,	dtype=jnp.bfloataa				,	safety_checker=snake_case_				,	)

						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)
						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images
						assert images.shape == (num_samples, 1, 5_12, 5_12, 3)
						__lowerCAmelCase	   =images[2, 0, 2_56, 10:17, 1]

						# With memory efficient attention
						__lowerCAmelCase   ,	__lowerCAmelCase	   =FlaxStableDiffusionPipeline.from_pretrained(
						    """CompVis/stable-diffusion-v1-4"""				,	revision="""bf16"""				,	dtype=jnp.bfloataa				,	safety_checker=snake_case_				,	use_memory_efficient_attention=snake_case_				,	)

						__lowerCAmelCase	   =replicate(snake_case_)
						__lowerCAmelCase	   =pipeline.prepare_inputs(snake_case_)
						__lowerCAmelCase	   =shard(snake_case_)
						__lowerCAmelCase	   =pipeline(snake_case_				,	snake_case_				,	snake_case_				,	jit=snake_case_).images
						assert images_eff.shape == (num_samples, 1, 5_12, 5_12, 3)
						__lowerCAmelCase	   =images[2, 0, 2_56, 10:17, 1]

						# I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
						# over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
						assert abs(slice_eff - slice).max() < 1e-2









from itertools import zip_longest

import requests
from bsa import BeautifulSoup
from pandas import DataFrame






def 					__lowerCAmelCase		(  __lowerCamelCase	:    str = "laptop"	)  ->						DataFrame:
					__lowerCAmelCase	   =f"""https://www.amazon.in/laptop/s?k={product}"""
					__lowerCAmelCase	   ={
					    """User-Agent""": """Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36
        (KHTML, like Gecko)Chrome/44.0.2403.157 Safari/537.36""",
					    """Accept-Language""": """en-US, en;q=0.5""",
					}
					__lowerCAmelCase	   =BeautifulSoup(requests.get(__lowerCamelCase				,   headers=__lowerCamelCase	).text	)
					# Initialize a Pandas dataframe with the column titles
					__lowerCAmelCase	   =DataFrame(
					    columns=[
					        """Product Title""",
					        """Product Link""",
					        """Current Price of the product""",
					        """Product Rating""",
					        """MRP of the product""",
					        """Discount""",
					    ]	)
					# Loop through each entry and store them in the dataframe
					for item, _ in zip_longest(
					    soup.find_all(
					        """div"""				,   attrs={"""class""": """s-result-item""", """data-component-type""": """s-search-result"""}				,   )				,   soup.find_all("""div"""				,   attrs={"""class""": """a-row a-size-base a-color-base"""}	)				,   ):
										try:
															__lowerCAmelCase	   =item.ha.text
															__lowerCAmelCase	   ="""https://www.amazon.in/""" + item.ha.a["""href"""]
															__lowerCAmelCase	   =item.find("""span"""				,   attrs={"""class""": """a-offscreen"""}	).text
															try:
																				__lowerCAmelCase	   =item.find("""span"""				,   attrs={"""class""": """a-icon-alt"""}	).text
															except AttributeError:
																				__lowerCAmelCase	   ="""Not available"""
															try:
																				__lowerCAmelCase	   =(
																				    """₹"""
																				    + item.find(
																				        """span"""				,   attrs={"""class""": """a-price a-text-price"""}	).text.split("""₹"""	)[1]
																				)
															except AttributeError:
																				__lowerCAmelCase	   =""""""
															try:
																				__lowerCAmelCase	   =float(
																				    (
																				        (
																				            float(product_mrp.strip("""₹"""	).replace(""","""				,   """"""	)	)
																				            - float(product_price.strip("""₹"""	).replace(""","""				,   """"""	)	)
																				        )
																				        / float(product_mrp.strip("""₹"""	).replace(""","""				,   """"""	)	)
																				    )
																				    * 100	)
															except ValueError:
																				__lowerCAmelCase	   =float("""nan"""	)
										except AttributeError:
															pass
										__lowerCAmelCase	   =[
										    product_title,
										    product_link,
										    product_price,
										    product_rating,
										    product_mrp,
										    discount,
										]
					__lowerCAmelCase	   =""" """
					__lowerCAmelCase	   =""" """
					data_frame.index += 1
					return data_frame


if __name__ == "__main__":
				lowercase_	       =			'''headphones'''
				get_amazon_product_data(product).to_csv(F"Amazon Product Data for {product}.csv")




