



import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

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


enable_full_determinism()





@skip_mps
class    lowerCamelCase__  (						lowercase__       ,    unittest.TestCase):
					"""simple docstring"""



					_A       =			TextToVideoSDPipeline
					_A       =			TEXT_TO_IMAGE_PARAMS
					_A       =			TEXT_TO_IMAGE_BATCH_PARAMS
					# No `output_type`.
					_A       =			frozenset(
					    [
					        'num_inference_steps',
					        'generator',
					        'latents',
					        'return_dict',
					        'callback',
					        'callback_steps',
					    ])







					def 						_a      (self    ):






											'''simple docstring'''



											torch.manual_seed(0    )
											lowerCamelCase								=		UNetaDConditionModel(
											    block_out_channels=(32, 64, 64, 64)				,			layers_per_block=2				,			sample_size=32				,			in_channels=4				,			out_channels=4				,			down_block_types=("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")				,			up_block_types=("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")				,			cross_attention_dim=32				,			attention_head_dim=4				,			)
											lowerCamelCase								=		DDIMScheduler(
											    beta_start=0.0_0085				,			beta_end=0.012				,			beta_schedule="scaled_linear"				,			clip_sample=__a				,			set_alpha_to_one=__a				,			)
											torch.manual_seed(0    )
											lowerCamelCase								=		AutoencoderKL(
											    block_out_channels=[32, 64]				,			in_channels=3				,			out_channels=3				,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]				,			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]				,			latent_channels=4				,			sample_size=1_28				,			)
											torch.manual_seed(0    )
											lowerCamelCase								=		CLIPTextConfig(
											    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1E-05				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=10_00				,			hidden_act="gelu"				,			projection_dim=5_12				,			)
											lowerCamelCase								=		CLIPTextModel(__a    )
											lowerCamelCase								=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )

											lowerCamelCase								=		{
											    "unet": unet,
											    "scheduler": scheduler,
											    "vae": vae,
											    "text_encoder": text_encoder,
											    "tokenizer": tokenizer,
											}
											return components







					def 						_a      (self				,			__a				,			__a=0    ):






											'''simple docstring'''



											if str(__a    ).startswith("mps"    ):
																	lowerCamelCase								=		torch.manual_seed(__a    )
											else:
																	lowerCamelCase								=		torch.Generator(device=__a    ).manual_seed(__a    )
											lowerCamelCase								=		{
											    "prompt": "A painting of a squirrel eating a burger",
											    "generator": generator,
											    "num_inference_steps": 2,
											    "guidance_scale": 6.0,
											    "output_type": "pt",
											}
											return inputs







					def 						_a      (self    ):






											'''simple docstring'''



											lowerCamelCase								=		"cpu"  # ensure determinism for the device-dependent torch.Generator
											lowerCamelCase								=		self.get_dummy_components()
											lowerCamelCase								=		TextToVideoSDPipeline(**__a    )
											lowerCamelCase								=		sd_pipe.to(__a    )
											sd_pipe.set_progress_bar_config(disable=__a    )

											lowerCamelCase								=		self.get_dummy_inputs(__a    )
											lowerCamelCase								=		"np"
											lowerCamelCase								=		sd_pipe(**__a    ).frames
											lowerCamelCase								=		frames[0][-3:, -3:, -1]

											assert frames[0].shape == (64, 64, 3)
											lowerCamelCase								=		np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]    )

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







					def 						_a      (self    ):






											'''simple docstring'''



											self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__a				,			expected_max_diff=3E-3    )







					@unittest.skipIf(
					    torch_device != "cuda" or not is_xformers_available()				,			reason="XFormers attention is only available with CUDA and `xformers` installed"				,			)
					def 						_a      (self    ):






											'''simple docstring'''



											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__a				,			expected_max_diff=1E-2    )







					@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."    )
					def 						_a      (self    ):






											'''simple docstring'''



											pass







					@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."    )
					def 						_a      (self    ):






											'''simple docstring'''



											pass







					@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."    )
					def 						_a      (self    ):






											'''simple docstring'''



											pass







					def 						_a      (self    ):






											'''simple docstring'''



											return super().test_progress_bar()





@slow
@skip_mps
class    lowerCamelCase__  (						unittest.TestCase):
					"""simple docstring"""



					def 						_a      (self    ):






											'''simple docstring'''



											lowerCamelCase								=		load_numpy(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"    )

											lowerCamelCase								=		TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"    )
											lowerCamelCase								=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config    )
											lowerCamelCase								=		pipe.to("cuda"    )

											lowerCamelCase								=		"Spiderman is surfing"
											lowerCamelCase								=		torch.Generator(device="cpu"    ).manual_seed(0    )

											lowerCamelCase								=		pipe(__a				,			generator=__a				,			num_inference_steps=25				,			output_type="pt"    ).frames
											lowerCamelCase								=		video_frames.cpu().numpy()

											assert np.abs(expected_video - video    ).mean() < 5E-2







					def 						_a      (self    ):






											'''simple docstring'''



											lowerCamelCase								=		load_numpy(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"    )

											lowerCamelCase								=		TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"    )
											lowerCamelCase								=		pipe.to("cuda"    )

											lowerCamelCase								=		"Spiderman is surfing"
											lowerCamelCase								=		torch.Generator(device="cpu"    ).manual_seed(0    )

											lowerCamelCase								=		pipe(__a				,			generator=__a				,			num_inference_steps=2				,			output_type="pt"    ).frames
											lowerCamelCase								=		video_frames.cpu().numpy()

											assert np.abs(expected_video - video    ).mean() < 5E-2




from __future__ import annotations

from collections.abc import Generator

import requests
from bsa import BeautifulSoup

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

def     __lowercase(	UpperCAmelCase__ = "mumbai" ):


      """simple docstring"""



      lowerCamelCase								=		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"} ):
            lowerCamelCase								=		job.find("a"   ,   attrs={"data-tn-element": "jobTitle"} ).text.strip()
            lowerCamelCase								=		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]}""")