import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
	import onnxruntime as ort

class        UpperCamelCase						(				__a	,	unittest.TestCase				):
						a__		:Union[str, Any]      =			'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''





						def        A_							(self			,     __UpperCamelCase=0						)				->				Union[str, Any]:
												UpperCamelCase_		:							str  =		floats_tensor((1, 3, 128, 128)			,     rng=random.Random(__UpperCamelCase						)						)
												UpperCamelCase_		:							str  =		np.random.RandomState(__UpperCamelCase						)
												UpperCamelCase_		:							Any  =		{
												    """prompt""": """A painting of a squirrel eating a burger""",
												    """image""": image,
												    """generator""": generator,
												    """num_inference_steps""": 3,
												    """strength""": 0.75,
												    """guidance_scale""": 7.5,
												    """output_type""": """numpy""",
												}
												return inputs





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							int  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							Dict  =		self.get_dummy_inputs()
												UpperCamelCase_		:							Optional[Any]  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							Optional[Any]  =		image[0, -3:, -3:, -1].flatten()

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							str  =		np.array([0.69_643, 0.58_484, 0.50_314, 0.58_760, 0.55_368, 0.59_643, 0.51_529, 0.41_217, 0.49_087]						)
												assert np.abs(image_slice - expected_slice						).max() < 1E-1





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							Optional[int]  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												UpperCamelCase_		:							int  =		PNDMScheduler.from_config(pipe.scheduler.config			,     skip_prk_steps=__UpperCamelCase						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							Union[str, Any]  =		self.get_dummy_inputs()
												UpperCamelCase_		:							List[str]  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							List[Any]  =		image[0, -3:, -3:, -1]

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							Tuple  =		np.array([0.61_737, 0.54_642, 0.53_183, 0.54_465, 0.52_742, 0.60_525, 0.49_969, 0.40_655, 0.48_154]						)

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





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							Any  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												UpperCamelCase_		:							List[Any]  =		LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												# warmup pass to apply optimizations
												UpperCamelCase_		:							Any  =		pipe(**self.get_dummy_inputs()						)

												UpperCamelCase_		:							int  =		self.get_dummy_inputs()
												UpperCamelCase_		:							List[str]  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							str  =		image[0, -3:, -3:, -1]

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							List[Any]  =		np.array([0.52_761, 0.59_977, 0.49_033, 0.49_619, 0.54_282, 0.50_311, 0.47_600, 0.40_918, 0.45_203]						)

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





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							str  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												UpperCamelCase_		:							Optional[int]  =		EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							int  =		self.get_dummy_inputs()
												UpperCamelCase_		:							Union[str, Any]  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							List[Any]  =		image[0, -3:, -3:, -1]

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							Dict  =		np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]						)

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





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_		:							List[str]  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												UpperCamelCase_		:							Union[str, Any]  =		EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							List[str]  =		self.get_dummy_inputs()
												UpperCamelCase_		:							Tuple  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							Dict  =		image[0, -3:, -3:, -1]

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							Optional[Any]  =		np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]						)

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





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							List[Any]  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint			,     provider="""CPUExecutionProvider"""						)
												UpperCamelCase_		:							Dict  =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							Tuple  =		self.get_dummy_inputs()
												UpperCamelCase_		:							Tuple  =		pipe(**__UpperCamelCase						).images
												UpperCamelCase_		:							List[str]  =		image[0, -3:, -3:, -1]

												assert image.shape == (1, 128, 128, 3)
												UpperCamelCase_		:							Dict  =		np.array([0.65_331, 0.58_277, 0.48_204, 0.56_059, 0.53_665, 0.56_235, 0.50_969, 0.40_009, 0.46_552]						)

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


@nightly
@require_onnxruntime
@require_torch_gpu
class        UpperCamelCase						(				unittest.TestCase				):





						@property
						def        A_							(self						)				->				str:
												return (
												    "CUDAExecutionProvider",
												    {
												        "gpu_mem_limit": "15000000000",  # 15GB
												        "arena_extend_strategy": "kSameAsRequested",
												    },
												)





						@property
						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							List[str]  =		ort.SessionOptions()
												UpperCamelCase_		:							List[Any]  =		False
												return options





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							Optional[Any]  =		load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/img2img/sketch-mountains-input.jpg"""						)
												UpperCamelCase_		:							int  =		init_image.resize((768, 512)						)
												# using the PNDM scheduler by default
												UpperCamelCase_		:							int  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    """CompVis/stable-diffusion-v1-4"""			,     revision="""onnx"""			,     safety_checker=__UpperCamelCase			,     feature_extractor=__UpperCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							Optional[int]  =		"""A fantasy landscape, trending on artstation"""

												UpperCamelCase_		:							int  =		np.random.RandomState(0						)
												UpperCamelCase_		:							Any  =		pipe(
												    prompt=__UpperCamelCase			,     image=__UpperCamelCase			,     strength=0.75			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=__UpperCamelCase			,     output_type="""np"""			,     )
												UpperCamelCase_		:							Any  =		output.images
												UpperCamelCase_		:							str  =		images[0, 255:258, 383:386, -1]

												assert images.shape == (1, 512, 768, 3)
												UpperCamelCase_		:							List[str]  =		np.array([0.4_909, 0.5_059, 0.5_372, 0.4_623, 0.4_876, 0.5_049, 0.4_820, 0.4_956, 0.5_019]						)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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





						def        A_							(self						)				->				Dict:
												UpperCamelCase_		:							str  =		load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/img2img/sketch-mountains-input.jpg"""						)
												UpperCamelCase_		:							List[Any]  =		init_image.resize((768, 512)						)
												UpperCamelCase_		:							List[Any]  =		LMSDiscreteScheduler.from_pretrained(
												    """runwayml/stable-diffusion-v1-5"""			,     subfolder="""scheduler"""			,     revision="""onnx"""						)
												UpperCamelCase_		:							Dict  =		OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    """runwayml/stable-diffusion-v1-5"""			,     revision="""onnx"""			,     scheduler=__UpperCamelCase			,     safety_checker=__UpperCamelCase			,     feature_extractor=__UpperCamelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
												pipe.set_progress_bar_config(disable=__UpperCamelCase						)

												UpperCamelCase_		:							Optional[Any]  =		"""A fantasy landscape, trending on artstation"""

												UpperCamelCase_		:							Optional[Any]  =		np.random.RandomState(0						)
												UpperCamelCase_		:							Union[str, Any]  =		pipe(
												    prompt=__UpperCamelCase			,     image=__UpperCamelCase			,     strength=0.75			,     guidance_scale=7.5			,     num_inference_steps=20			,     generator=__UpperCamelCase			,     output_type="""np"""			,     )
												UpperCamelCase_		:							Optional[int]  =		output.images
												UpperCamelCase_		:							Any  =		images[0, 255:258, 383:386, -1]

												assert images.shape == (1, 512, 768, 3)
												UpperCamelCase_		:							Dict  =		np.array([0.8_043, 0.926, 0.9_581, 0.8_119, 0.8_954, 0.913, 0.7_209, 0.7_463, 0.7_431]						)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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







from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

SCREAMING_SNAKE_CASE		:     Union[str, Any]         =	{"UserAgent": UserAgent().random}






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Dict			):
						UpperCamelCase_		:							Tuple  =		script.contents[0]
						UpperCamelCase_		:							List[Any]  =		json.loads(data[data.find("""{\"config\""""			) : -1]			)
						return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]

class        UpperCamelCase						:





						def __init__(self			,     __UpperCamelCase						)				->				List[str]:
												UpperCamelCase_		:							Union[str, Any]  =		f'''https://www.instagram.com/{username}/'''
												UpperCamelCase_		:							Optional[int]  =		self.get_json()





						def        A_							(self						)				->				dict:
												UpperCamelCase_		:							Optional[Any]  =		requests.get(self.url			,     headers=__UpperCamelCase						).text
												UpperCamelCase_		:							Any  =		BeautifulSoup(__UpperCamelCase			,     """html.parser"""						).find_all("""script"""						)
												try:
																		return extract_user_profile(scripts[4]						)
												except (json.decoder.JSONDecodeError, KeyError):
																		return extract_user_profile(scripts[3]						)





						def __repr__(self						)				->				str:
												return f'''{self.__class__.__name__}(\'{self.username}\')'''





						def __str__(self						)				->				str:
												return f'''{self.fullname} ({self.username}) is {self.biography}'''





						@property
						def        A_							(self						)				->				str:
												return self.user_data["username"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["full_name"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["biography"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["business_email"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["external_url"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_followed_by"]["count"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_follow"]["count"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_owner_to_timeline_media"]["count"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["profile_pic_url_hd"]





						@property
						def        A_							(self						)				->				bool:
												return self.user_data["is_verified"]





						@property
						def        A_							(self						)				->				bool:
												return self.user_data["is_private"]






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				str = "github"			):
						import os

						if os.environ.get("""CI"""			):
												return  # test failing on GitHub Actions
						UpperCamelCase_		:							Any  =		InstagramUser(_SCREAMING_SNAKE_CASE			)
						assert instagram_user.user_data
						assert isinstance(instagram_user.user_data		, _SCREAMING_SNAKE_CASE			)
						assert instagram_user.username == username
						if username != "github":
												return
						assert instagram_user.fullname == "GitHub"
						assert instagram_user.biography == "Built for developers."
						assert instagram_user.number_of_posts > 150
						assert instagram_user.number_of_followers > 12_0000
						assert instagram_user.number_of_followings > 15
						assert instagram_user.email == "support@github.com"
						assert instagram_user.website == "https://github.com/readme"
						assert instagram_user.profile_picture_url.startswith("""https://instagram."""			)
						assert instagram_user.is_verified is True
						assert instagram_user.is_private is False


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	SCREAMING_SNAKE_CASE		:     Dict         =	InstagramUser("github")
	print(instagram_user)
	print(F'''{instagram_user.number_of_posts = }''')
	print(F'''{instagram_user.number_of_followers = }''')
	print(F'''{instagram_user.number_of_followings = }''')
	print(F'''{instagram_user.email = }''')
	print(F'''{instagram_user.website = }''')
	print(F'''{instagram_user.profile_picture_url = }''')
	print(F'''{instagram_user.is_verified = }''')
	print(F'''{instagram_user.is_private = }''')






