




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference

class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE							,			unittest.TestCase   ):

      """simple docstring"""

      lowerCAmelCase__			: List[str]    =					ShapEImgaImgPipeline
      lowerCAmelCase__			: List[str]    =					["image"]
      lowerCAmelCase__			: Dict    =					["image"]
      lowerCAmelCase__			: Optional[int]    =					[
          "num_images_per_prompt",
          "num_inference_steps",
          "generator",
          "latents",
          "guidance_scale",
          "frame_size",
          "output_type",
          "return_dict",
      ]
      lowerCAmelCase__			: Dict    =					False







      @property
      def       snake_case	(     self					: Dict				):
          return 32







      @property
      def       snake_case	(     self					: Tuple				):
          return 32







      @property
      def       snake_case	(     self					: Optional[Any]				):
          return self.time_input_dim * 4







      @property
      def       snake_case	(     self					: Optional[int]				):
          return 8







      @property
      def       snake_case	(     self					: Dict				):
          torch.manual_seed(0				)
          __UpperCamelCase  		=						CLIPVisionConfig(
              hidden_size=self.text_embedder_hidden_size ,       image_size=64 ,       projection_dim=self.text_embedder_hidden_size ,       intermediate_size=37 ,       num_attention_heads=4 ,       num_channels=3 ,       num_hidden_layers=5 ,       patch_size=1 ,       )

          __UpperCamelCase  		=						CLIPVisionModel(snake_case				)
          return model







      @property
      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						CLIPImageProcessor(
              crop_size=224 ,       do_center_crop=snake_case ,       do_normalize=snake_case ,       do_resize=snake_case ,       image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73] ,       image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11] ,       resample=3 ,       size=224 ,       )

          return image_processor







      @property
      def       snake_case	(     self					: str				):
          torch.manual_seed(0				)

          __UpperCamelCase  		=						{
              '''num_attention_heads''': 2,
              '''attention_head_dim''': 16,
              '''embedding_dim''': self.time_input_dim,
              '''num_embeddings''': 32,
              '''embedding_proj_dim''': self.text_embedder_hidden_size,
              '''time_embed_dim''': self.time_embed_dim,
              '''num_layers''': 1,
              '''clip_embed_dim''': self.time_input_dim * 2,
              '''additional_embeddings''': 0,
              '''time_embed_act_fn''': '''gelu''',
              '''norm_in_type''': '''layer''',
              '''embedding_proj_norm_type''': '''layer''',
              '''encoder_hid_proj_type''': None,
              '''added_emb_type''': None,
          }

          __UpperCamelCase  		=						PriorTransformer(**snake_case				)
          return model







      @property
      def       snake_case	(     self					: Optional[int]				):
          torch.manual_seed(0				)

          __UpperCamelCase  		=						{
              '''param_shapes''': (
                  (self.renderer_dim, 93),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
              ),
              '''d_latent''': self.time_input_dim,
              '''d_hidden''': self.renderer_dim,
              '''n_output''': 12,
              '''background''': (
                  0.1,
                  0.1,
                  0.1,
              ),
          }
          __UpperCamelCase  		=						ShapERenderer(**snake_case				)
          return model







      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						self.dummy_prior
          __UpperCamelCase  		=						self.dummy_image_encoder
          __UpperCamelCase  		=						self.dummy_image_processor
          __UpperCamelCase  		=						self.dummy_renderer

          __UpperCamelCase  		=						HeunDiscreteScheduler(
              beta_schedule='''exp''' ,       num_train_timesteps=1024 ,       prediction_type='''sample''' ,       use_karras_sigmas=snake_case ,       clip_sample=snake_case ,       clip_sample_range=1.0 ,       )
          __UpperCamelCase  		=						{
              '''prior''': prior,
              '''image_encoder''': image_encoder,
              '''image_processor''': image_processor,
              '''renderer''': renderer,
              '''scheduler''': scheduler,
          }

          return components







      def       snake_case	(     self					: List[str] ,       snake_case					: Union[str, Any] ,       snake_case					: Optional[Any]=0				):
          __UpperCamelCase  		=						floats_tensor((1, 3, 64, 64) ,       rng=random.Random(snake_case				)				).to(snake_case				)

          if str(snake_case				).startswith('''mps'''				):
              __UpperCamelCase  		=						torch.manual_seed(snake_case				)
          else:
              __UpperCamelCase  		=						torch.Generator(device=snake_case				).manual_seed(snake_case				)
          __UpperCamelCase  		=						{
              '''image''': input_image,
              '''generator''': generator,
              '''num_inference_steps''': 1,
              '''frame_size''': 32,
              '''output_type''': '''np''',
          }
          return inputs







      def       snake_case	(     self					: int				):
          __UpperCamelCase  		=						'''cpu'''

          __UpperCamelCase  		=						self.get_dummy_components()

          __UpperCamelCase  		=						self.pipeline_class(**snake_case				)
          __UpperCamelCase  		=						pipe.to(snake_case				)

          pipe.set_progress_bar_config(disable=snake_case				)

          __UpperCamelCase  		=						pipe(**self.get_dummy_inputs(snake_case				)				)
          __UpperCamelCase  		=						output.images[0]
          __UpperCamelCase  		=						image[0, -3:, -3:, -1]

          assert image.shape == (20, 32, 32, 3)

          __UpperCamelCase  		=						np.array(
              [
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
              ]				)

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







      def       snake_case	(     self					: Dict				):
          # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
          self._test_inference_batch_consistent(batch_sizes=[1, 2]				)







      def       snake_case	(     self					: Dict				):
          __UpperCamelCase  		=						torch_device == '''cpu'''
          __UpperCamelCase  		=						True
          self._test_inference_batch_single_identical(
              batch_size=2 ,       test_max_difference=snake_case ,       relax_max_difference=snake_case ,       )







      def       snake_case	(     self					: List[str]				):
          __UpperCamelCase  		=						self.get_dummy_components()
          __UpperCamelCase  		=						self.pipeline_class(**snake_case				)
          __UpperCamelCase  		=						pipe.to(snake_case				)
          pipe.set_progress_bar_config(disable=snake_case				)

          __UpperCamelCase  		=						1
          __UpperCamelCase  		=						2

          __UpperCamelCase  		=						self.get_dummy_inputs(snake_case				)

          for key in inputs.keys():
              if key in self.batch_params:
                  __UpperCamelCase  		=						batch_size * [inputs[key]]

          __UpperCamelCase  		=						pipe(**snake_case ,       num_images_per_prompt=snake_case				)[0]

          assert images.shape[0] == batch_size * num_images_per_prompt







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

      """simple docstring"""

      def       snake_case	(     self					: str				):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







      def       snake_case	(     self					: List[str]				):
          __UpperCamelCase  		=						load_image(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''				)
          __UpperCamelCase  		=						load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
              '''/shap_e/test_shap_e_img2img_out.npy'''				)
          __UpperCamelCase  		=						ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''				)
          __UpperCamelCase  		=						pipe.to(snake_case				)
          pipe.set_progress_bar_config(disable=snake_case				)

          __UpperCamelCase  		=						torch.Generator(device=snake_case				).manual_seed(0				)

          __UpperCamelCase  		=						pipe(
              snake_case ,       generator=snake_case ,       guidance_scale=3.0 ,       num_inference_steps=64 ,       frame_size=64 ,       output_type='''np''' ,       ).images[0]

          assert images.shape == (20, 64, 64, 3)

          assert_mean_pixel_difference(snake_case ,       snake_case				)












import sys
import webbrowser

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
 print("Googling.....")
 a_   		=     "https://www.google.com/search?q=" + " ".join(sys.argv[1:])
 a_   		=     requests.get(url, headers={"UserAgent": UserAgent().random})
 # res.raise_for_status()
 with open("project1a.html", "wb") as out_file:  # only for knowing the class
  for data in res.iter_content(1_0000):
   out_file.write(data)
 a_   		=     BeautifulSoup(res.text, "html.parser")
 a_   		=     list(soup.select(".eZt8xd"))[:5]

 print(len(links))
 for link in links:
  if link.text == "Maps":
   webbrowser.open(link.get("href"))
  else:
   webbrowser.open(f"""https://google.com{link.get('href')}""")






