import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class     lowerCAmelCase__     (				__snake_case     ,unittest.TestCase			):


		'''simple docstring'''






		lowerCAmelCase_     =   LDMTextToImagePipeline
		lowerCAmelCase_     =   TEXT_TO_IMAGE_PARAMS - {
		    """negative_prompt""",
		    """negative_prompt_embeds""",
		    """cross_attention_kwargs""",
		    """prompt_embeds""",
		}
		lowerCAmelCase_     =   PipelineTesterMixin.required_optional_params - {
		    """num_images_per_prompt""",
		    """callback""",
		    """callback_steps""",
		}
		lowerCAmelCase_     =   TEXT_TO_IMAGE_BATCH_PARAMS
		lowerCAmelCase_     =   False
		def   _snake_case       (       self     :     Optional[int]		)      ->	List[Any]:
				torch.manual_seed(0		)
				_lowerCamelCase				   =  UNetaDConditionModel(
				    block_out_channels=(3_2, 6_4)     ,  layers_per_block=2     ,  sample_size=3_2     ,  in_channels=4     ,  out_channels=4     ,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,  up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     ,  cross_attention_dim=3_2     ,  )
				_lowerCamelCase				   =  DDIMScheduler(
				    beta_start=0.0_0085     ,  beta_end=0.012     ,  beta_schedule='scaled_linear'     ,  clip_sample=snake_case__     ,  set_alpha_to_one=snake_case__     ,  )
				torch.manual_seed(0		)
				_lowerCamelCase				   =  AutoencoderKL(
				    block_out_channels=(3_2, 6_4)     ,  in_channels=3     ,  out_channels=3     ,  down_block_types=('DownEncoderBlock2D', 'DownEncoderBlock2D')     ,  up_block_types=('UpDecoderBlock2D', 'UpDecoderBlock2D')     ,  latent_channels=4     ,  )
				torch.manual_seed(0		)
				_lowerCamelCase				   =  CLIPTextConfig(
				    bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=3_2     ,  intermediate_size=3_7     ,  layer_norm_eps=1e-05     ,  num_attention_heads=4     ,  num_hidden_layers=5     ,  pad_token_id=1     ,  vocab_size=1_0_0_0     ,  )
				_lowerCamelCase				   =  CLIPTextModel(snake_case__		)
				_lowerCamelCase				   =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

				_lowerCamelCase				   =  {
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vqvae""": vae,
				    """bert""": text_encoder,
				    """tokenizer""": tokenizer,
				}
				return components
		def   _snake_case       (       self     :     Optional[Any]     ,  snake_case__     :     str     ,  snake_case__     :     List[Any]=0		)      ->	int:
				if str(snake_case__		).startswith('mps'		):
						_lowerCamelCase				   =  torch.manual_seed(snake_case__		)
				else:
						_lowerCamelCase				   =  torch.Generator(device=snake_case__		).manual_seed(snake_case__		)
				_lowerCamelCase				   =  {
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """generator""": generator,
				    """num_inference_steps""": 2,
				    """guidance_scale""": 6.0,
				    """output_type""": """numpy""",
				}
				return inputs



		def   _snake_case       (       self     :     Tuple		)      ->	Optional[Any]:
				_lowerCamelCase				   =  """cpu"""  # ensure determinism for the device-dependent torch.Generator

				_lowerCamelCase				   =  self.get_dummy_components()
				_lowerCamelCase				   =  LDMTextToImagePipeline(**snake_case__		)
				pipe.to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  self.get_dummy_inputs(snake_case__		)
				_lowerCamelCase				   =  pipe(**snake_case__		).images
				_lowerCamelCase				   =  image[0, -3:, -3:, -1]

				assert image.shape == (1, 1_6, 1_6, 3)
				_lowerCamelCase				   =  np.array([0.6101, 0.6156, 0.5622, 0.4895, 0.6661, 0.3804, 0.5748, 0.6136, 0.5014]		)

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





@slow
@require_torch_gpu
class     lowerCAmelCase__     (				unittest.TestCase			):


		'''simple docstring'''






		def   _snake_case       (       self     :     str		)      ->	int:
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
		def   _snake_case       (       self     :     List[Any]     ,  snake_case__     :     Optional[int]     ,  snake_case__     :     Dict=torch.floataa     ,  snake_case__     :     List[Any]=0		)      ->	Tuple:
				_lowerCamelCase				   =  torch.manual_seed(snake_case__		)
				_lowerCamelCase				   =  np.random.RandomState(snake_case__		).standard_normal((1, 4, 3_2, 3_2)		)
				_lowerCamelCase				   =  torch.from_numpy(snake_case__		).to(device=snake_case__     ,  dtype=snake_case__		)
				_lowerCamelCase				   =  {
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """latents""": latents,
				    """generator""": generator,
				    """num_inference_steps""": 3,
				    """guidance_scale""": 6.0,
				    """output_type""": """numpy""",
				}
				return inputs



		def   _snake_case       (       self     :     Union[str, Any]		)      ->	Union[str, Any]:
				_lowerCamelCase				   =  LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256'		).to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  self.get_inputs(snake_case__		)
				_lowerCamelCase				   =  pipe(**snake_case__		).images
				_lowerCamelCase				   =  image[0, -3:, -3:, -1].flatten()

				assert image.shape == (1, 2_5_6, 2_5_6, 3)
				_lowerCamelCase				   =  np.array([0.5_1825, 0.5_2850, 0.5_2543, 0.5_4258, 0.5_2304, 0.5_2569, 0.5_4363, 0.5_5276, 0.5_6878]		)
				_lowerCamelCase				   =  np.abs(expected_slice - image_slice		).max()
				assert max_diff < 1e-3





@nightly
@require_torch_gpu
class     lowerCAmelCase__     (				unittest.TestCase			):


		'''simple docstring'''






		def   _snake_case       (       self     :     Optional[int]		)      ->	List[Any]:
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
		def   _snake_case       (       self     :     Any     ,  snake_case__     :     int     ,  snake_case__     :     int=torch.floataa     ,  snake_case__     :     List[Any]=0		)      ->	List[Any]:
				_lowerCamelCase				   =  torch.manual_seed(snake_case__		)
				_lowerCamelCase				   =  np.random.RandomState(snake_case__		).standard_normal((1, 4, 3_2, 3_2)		)
				_lowerCamelCase				   =  torch.from_numpy(snake_case__		).to(device=snake_case__     ,  dtype=snake_case__		)
				_lowerCamelCase				   =  {
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """latents""": latents,
				    """generator""": generator,
				    """num_inference_steps""": 5_0,
				    """guidance_scale""": 6.0,
				    """output_type""": """numpy""",
				}
				return inputs



		def   _snake_case       (       self     :     Dict		)      ->	int:
				_lowerCamelCase				   =  LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256'		).to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  self.get_inputs(snake_case__		)
				_lowerCamelCase				   =  pipe(**snake_case__		).images[0]

				_lowerCamelCase				   =  load_numpy(
				    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy'		)
				_lowerCamelCase				   =  np.abs(expected_image - image		).max()
				assert max_diff < 1e-3







"""simple docstring"""







import requests
from bsa import BeautifulSoup


def      UpperCamelCase       ( _A = "AAPL" )     ->       str:
				lowercase    :      Optional[Any]       = F"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
				lowercase    :      str       = BeautifulSoup(requests.get(_A ).text  ,				"""html.parser""" )
				lowercase    :      int       = """My(6px) Pos(r) smartphone_Mt(6px)"""
				return soup.find("""div"""  ,				class_=class_ ).find("""span""" ).text


if __name__ == "__main__":
				for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
								print(F'Current {symbol:<4} stock price is {stock_price(symbol):>8}')
