






import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class      UpperCamelCase (				snake_case__			,       snake_case__			,       unittest.TestCase ):







  """simple docstring"""



  snake_case    =   StableDiffusionDiffEditPipeline
  snake_case    =   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
  snake_case    =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
  snake_case    =   frozenset(
      [] )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
  snake_case    =   frozenset([] )
  def       A(  self		:       Any		)    ->   Union[str, Any]:


      '''simple docstring'''
      torch.manual_seed(0		)
      A	 =      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						,attention_head_dim=(2, 4)						,use_linear_projection=_SCREAMING_SNAKE_CASE						,)
      A	 =      DDIMScheduler(
          beta_start=0.00085						,beta_end=0.012						,beta_schedule='scaled_linear'						,clip_sample=_SCREAMING_SNAKE_CASE						,set_alpha_to_one=_SCREAMING_SNAKE_CASE						,)
      A	 =      DDIMInverseScheduler(
          beta_start=0.00085						,beta_end=0.012						,beta_schedule='scaled_linear'						,clip_sample=_SCREAMING_SNAKE_CASE						,set_alpha_to_zero=_SCREAMING_SNAKE_CASE						,)
      torch.manual_seed(0		)
      A	 =      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						,sample_size=1_2_8						,)
      torch.manual_seed(0		)
      A	 =      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						,hidden_act='gelu'						,projection_dim=5_1_2						,)
      A	 =      CLIPTextModel(_SCREAMING_SNAKE_CASE		)
      A	 =      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

      A	 =      {
          'unet': unet,
          'scheduler': scheduler,
          'inverse_scheduler': inverse_scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }

      return components
  def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Any=0		)    ->   Optional[int]:


      '''simple docstring'''
      A	 =      floats_tensor((1, 1_6, 1_6)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
      A	 =      floats_tensor((1, 2, 4, 1_6, 1_6)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
      if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
          A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
      else:
          A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
      A	 =      {
          'prompt': 'a dog and a newt',
          'mask_image': mask,
          'image_latents': latents,
          'generator': generator,
          'num_inference_steps': 2,
          'inpaint_strength': 1.0,
          'guidance_scale': 6.0,
          'output_type': 'numpy',
      }

      return inputs
  def       A(  self		:       List[str]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=0		)    ->   Any:


      '''simple docstring'''
      A	 =      floats_tensor((1, 3, 3_2, 3_2)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
      A	 =      image.cpu().permute(0						,2						,3						,1		)[0]
      A	 =      Image.fromarray(np.uinta(_SCREAMING_SNAKE_CASE		)		).convert('RGB'		)
      if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
          A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
      else:
          A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
      A	 =      {
          'image': image,
          'source_prompt': 'a cat and a frog',
          'target_prompt': 'a dog and a newt',
          'generator': generator,
          'num_inference_steps': 2,
          'num_maps_per_mask': 2,
          'mask_encode_strength': 1.0,
          'guidance_scale': 6.0,
          'output_type': 'numpy',
      }

      return inputs
  def       A(  self		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]=0		)    ->   Any:


      '''simple docstring'''
      A	 =      floats_tensor((1, 3, 3_2, 3_2)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
      A	 =      image.cpu().permute(0						,2						,3						,1		)[0]
      A	 =      Image.fromarray(np.uinta(_SCREAMING_SNAKE_CASE		)		).convert('RGB'		)
      if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
          A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
      else:
          A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
      A	 =      {
          'image': image,
          'prompt': 'a cat and a frog',
          'generator': generator,
          'num_inference_steps': 2,
          'inpaint_strength': 1.0,
          'guidance_scale': 6.0,
          'decode_latents': True,
          'output_type': 'numpy',
      }
      return inputs
  def       A(  self		:       int		)    ->   Tuple:


      '''simple docstring'''
      if not hasattr(self.pipeline_class						,'_optional_components'		):
          return

      A	 =      self.get_dummy_components()
      A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
      pipe.to(_SCREAMING_SNAKE_CASE		)
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      # set all optional components to None and update pipeline config accordingly
      for optional_component in pipe._optional_components:
          setattr(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
      pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}		)

      A	 =      self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
      A	 =      pipe(**_SCREAMING_SNAKE_CASE		)[0]

      with tempfile.TemporaryDirectory() as tmpdir:
          pipe.save_pretrained(_SCREAMING_SNAKE_CASE		)
          A	 =      self.pipeline_class.from_pretrained(_SCREAMING_SNAKE_CASE		)
          pipe_loaded.to(_SCREAMING_SNAKE_CASE		)
          pipe_loaded.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      for optional_component in pipe._optional_components:
          self.assertTrue(
              getattr(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		) is None						,f'`{optional_component}` did not stay set to None after loading.'						,)

      A	 =      self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
      A	 =      pipe_loaded(**_SCREAMING_SNAKE_CASE		)[0]

      A	 =      np.abs(output - output_loaded		).max()
      self.assertLess(_SCREAMING_SNAKE_CASE						,1E-4		)
  def       A(  self		:       List[Any]		)    ->   List[Any]:


      '''simple docstring'''
      A	 =      'cpu'

      A	 =      self.get_dummy_components()
      A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
      pipe.to(_SCREAMING_SNAKE_CASE		)
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      A	 =      self.get_dummy_mask_inputs(_SCREAMING_SNAKE_CASE		)
      A	 =      pipe.generate_mask(**_SCREAMING_SNAKE_CASE		)
      A	 =      mask[0, -3:, -3:]

      self.assertEqual(mask.shape						,(1, 1_6, 1_6)		)
      A	 =      np.array([0] * 9		)
      A	 =      np.abs(mask_slice.flatten() - expected_slice		).max()
      self.assertLessEqual(_SCREAMING_SNAKE_CASE						,1E-3		)
      self.assertEqual(mask[0, -3, -4]						,0		)
  def       A(  self		:       List[str]		)    ->   Optional[Any]:


      '''simple docstring'''
      A	 =      'cpu'

      A	 =      self.get_dummy_components()
      A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
      pipe.to(_SCREAMING_SNAKE_CASE		)
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      A	 =      self.get_dummy_inversion_inputs(_SCREAMING_SNAKE_CASE		)
      A	 =      pipe.invert(**_SCREAMING_SNAKE_CASE		).images
      A	 =      image[0, -1, -3:, -3:]

      self.assertEqual(image.shape						,(2, 3_2, 3_2, 3)		)
      A	 =      np.array(
          [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]						,)
      A	 =      np.abs(image_slice.flatten() - expected_slice		).max()
      self.assertLessEqual(_SCREAMING_SNAKE_CASE						,1E-3		)
  def       A(  self		:       Optional[Any]		)    ->   Dict:


      '''simple docstring'''
      super().test_inference_batch_single_identical(expected_max_diff=5E-3		)







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


      '''simple docstring'''
      A	 =      'cpu'

      A	 =      self.get_dummy_components()

      A	 =      {'beta_start': 0.00085, 'beta_end': 0.012, 'beta_schedule': 'scaled_linear'}
      A	 =      DPMSolverMultistepScheduler(**_SCREAMING_SNAKE_CASE		)
      A	 =      DPMSolverMultistepInverseScheduler(**_SCREAMING_SNAKE_CASE		)

      A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
      pipe.to(_SCREAMING_SNAKE_CASE		)
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      A	 =      self.get_dummy_inversion_inputs(_SCREAMING_SNAKE_CASE		)
      A	 =      pipe.invert(**_SCREAMING_SNAKE_CASE		).images
      A	 =      image[0, -1, -3:, -3:]

      self.assertEqual(image.shape						,(2, 3_2, 3_2, 3)		)
      A	 =      np.array(
          [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]						,)
      A	 =      np.abs(image_slice.flatten() - expected_slice		).max()
      self.assertLessEqual(_SCREAMING_SNAKE_CASE						,1E-3		)


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







  """simple docstring"""



  def       A(  self		:       List[str]		)    ->   int:


      '''simple docstring'''
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()
  @classmethod
  def       A(  cls		:       Optional[int]		)    ->   Dict:


      '''simple docstring'''
      A	 =      load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'		)

      A	 =      raw_image.convert('RGB'		).resize((7_6_8, 7_6_8)		)

      A	 =      raw_image
  def       A(  self		:       Tuple		)    ->   List[str]:


      '''simple docstring'''
      A	 =      torch.manual_seed(0		)

      A	 =      StableDiffusionDiffEditPipeline.from_pretrained(
          'stabilityai/stable-diffusion-2-1'						,safety_checker=_SCREAMING_SNAKE_CASE						,torch_dtype=torch.floataa		)
      A	 =      DDIMScheduler.from_config(pipe.scheduler.config		)
      A	 =      DDIMInverseScheduler.from_config(pipe.scheduler.config		)
      pipe.enable_model_cpu_offload()
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      A	 =      'a bowl of fruit'
      A	 =      'a bowl of pears'

      A	 =      pipe.generate_mask(
          image=self.raw_image						,source_prompt=_SCREAMING_SNAKE_CASE						,target_prompt=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,)

      A	 =      pipe.invert(
          prompt=_SCREAMING_SNAKE_CASE						,image=self.raw_image						,inpaint_strength=0.7						,generator=_SCREAMING_SNAKE_CASE		).latents

      A	 =      pipe(
          prompt=_SCREAMING_SNAKE_CASE						,mask_image=_SCREAMING_SNAKE_CASE						,image_latents=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,negative_prompt=_SCREAMING_SNAKE_CASE						,inpaint_strength=0.7						,output_type='numpy'						,).images[0]

      A	 =      (
          np.array(
              load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                  '/diffedit/pears.png'		).resize((7_6_8, 7_6_8)		)		)
          / 2_5_5
      )
      assert np.abs((expected_image - image).max()		) < 5E-1







  def       A(  self		:       Any		)    ->   int:


      '''simple docstring'''
      A	 =      torch.manual_seed(0		)

      A	 =      StableDiffusionDiffEditPipeline.from_pretrained(
          'stabilityai/stable-diffusion-2-1'						,safety_checker=_SCREAMING_SNAKE_CASE						,torch_dtype=torch.floataa		)
      A	 =      DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
      A	 =      DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config		)
      pipe.enable_model_cpu_offload()
      pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

      A	 =      'a bowl of fruit'
      A	 =      'a bowl of pears'

      A	 =      pipe.generate_mask(
          image=self.raw_image						,source_prompt=_SCREAMING_SNAKE_CASE						,target_prompt=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,)

      A	 =      pipe.invert(
          prompt=_SCREAMING_SNAKE_CASE						,image=self.raw_image						,inpaint_strength=0.7						,generator=_SCREAMING_SNAKE_CASE						,num_inference_steps=2_5						,).latents

      A	 =      pipe(
          prompt=_SCREAMING_SNAKE_CASE						,mask_image=_SCREAMING_SNAKE_CASE						,image_latents=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,negative_prompt=_SCREAMING_SNAKE_CASE						,inpaint_strength=0.7						,num_inference_steps=2_5						,output_type='numpy'						,).images[0]

      A	 =      (
          np.array(
              load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                  '/diffedit/pears.png'		).resize((7_6_8, 7_6_8)		)		)
          / 2_5_5
      )
      assert np.abs((expected_image - image).max()		) < 5E-1













from __future__ import annotations

from collections.abc import Generator

import requests
from bsa import BeautifulSoup

lowerCAmelCase_           = 'https://www.indeed.co.in/jobs?q=mobile+app+development&l='







def      snake_case		(							UpperCAmelCase	:       str = "mumbai"   ):
				A	 =      BeautifulSoup(requests.get(url + location   ).content,						'html.parser'   )
				# This attribute finds out all the specifics listed in a job
				for job in soup.find_all('div',						attrs={'data-tn-component': 'organicJob'}   ):
								A	 =      job.find('a',						attrs={'data-tn-element': 'jobTitle'}   ).text.strip()
								A	 =      job.find('span',						{'class': 'company'}   ).text.strip()
								yield job_title, company_name


if __name__ == "__main__":
					for i, job in enumerate(fetch_jobs('Bangalore'), 1):
										print(f'''Job {i:>2} is {job[0]} at {job[1]}''')





