


from typing import Callable, List, Optional, Union

import torch

from ...models import UNetaDModel
from ...schedulers import CMStochasticIterativeScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


_lowerCAmelCase:	Dict      							=					logging.get_logger(__name__)  # pylint: disable=invalid-name


_lowerCAmelCase:	Tuple      							=					'\n    Examples:\n        ```py\n        >>> import torch\n\n        >>> from diffusers import ConsistencyModelPipeline\n\n        >>> device = "cuda"\n        >>> # Load the cd_imagenet64_l2 checkpoint.\n        >>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2"\n        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)\n        >>> pipe.to(device)\n\n        >>> # Onestep Sampling\n        >>> image = pipe(num_inference_steps=1).images[0]\n        >>> image.save("cd_imagenet64_l2_onestep_sample.png")\n\n        >>> # Onestep sampling, class-conditional image generation\n        >>> # ImageNet-64 class label 145 corresponds to king penguins\n        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]\n        >>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png")\n\n        >>> # Multistep sampling, class-conditional image generation\n        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:\n        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77\n        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]\n        >>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png")\n        ```\n'




class 			lowercase_				(lowercase__      ):





				def __init__(							self					,     lowercase_					,     lowercase_)     ->   None:
											super().__init__()

											self.register_modules(
											    unet=lowercase_					,     scheduler=lowercase_					,     )

											a__     						=None





				def 	__UpperCamelCase						(							self					,     lowercase_=0)     ->   Union[str, Any]:
											if is_accelerate_available() and is_accelerate_version('>='					,     '0.14.0'):
																		from accelerate import cpu_offload
											else:
																		raise ImportError('`enable_sequential_cpu_offload` requires `accelerate v0.14.0` or higher')

											a__     						=torch.device(F"""cuda:{gpu_id}""")

											if self.device.type != "cpu":
																		self.to('cpu'					,     silence_dtype_warnings=lowercase_)
																		torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

											for cpu_offloaded_model in [self.unet]:
																		cpu_offload(lowercase_					,     lowercase_)

											if self.safety_checker is not None:
																		cpu_offload(self.safety_checker					,     execution_device=lowercase_					,     offload_buffers=lowercase_)





				def 	__UpperCamelCase						(							self					,     lowercase_=0)     ->   Optional[Any]:
											if is_accelerate_available() and is_accelerate_version('>='					,     '0.17.0.dev0'):
																		from accelerate import cpu_offload_with_hook
											else:
																		raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.')

											a__     						=torch.device(F"""cuda:{gpu_id}""")

											if self.device.type != "cpu":
																		self.to('cpu'					,     silence_dtype_warnings=lowercase_)
																		torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

											a__     						=None
											for cpu_offloaded_model in [self.unet]:
																		a__						,    a__     						=cpu_offload_with_hook(lowercase_					,     lowercase_					,     prev_module_hook=lowercase_)

											if self.safety_checker is not None:
																		a__						,    a__     						=cpu_offload_with_hook(self.safety_checker					,     lowercase_					,     prev_module_hook=lowercase_)

											# We'll offload the last model manually.
											a__     						=hook





				@property
				# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
				def 	__UpperCamelCase						(							self)     ->   List[str]:
											if not hasattr(self.unet					,     '_hf_hook'):
																		return self.device
											for module in self.unet.modules():
																		if (
																		    hasattr(lowercase_					,     '_hf_hook')
																		    and hasattr(module._hf_hook					,     'execution_device')
																		    and module._hf_hook.execution_device is not None
																		):
																									return torch.device(module._hf_hook.execution_device)
											return self.device





				def 	__UpperCamelCase						(							self					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_=None)     ->   Optional[int]:
											a__     						=(batch_size, num_channels, height, width)
											if isinstance(lowercase_					,     lowercase_) and len(lowercase_) != batch_size:
																		raise ValueError(
																		    F"""You have passed a list of generators of length {len(lowercase_)}, but requested an effective batch"""
																		    F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""")

											if latents is None:
																		a__     						=randn_tensor(lowercase_					,     generator=lowercase_					,     device=lowercase_					,     dtype=lowercase_)
											else:
																		a__     						=latents.to(device=lowercase_					,     dtype=lowercase_)

											# scale the initial noise by the standard deviation required by the scheduler
											a__     						=latents * self.scheduler.init_noise_sigma
											return latents





				def 	__UpperCamelCase						(							self					,     lowercase_					,     lowercase_ = "pil")     ->   Tuple:
											if output_type not in ["pt", "np", "pil"]:
																		raise ValueError(
																		    F"""output_type={output_type} is not supported. Make sure to choose one of ['pt', 'np', or 'pil']""")

											# Equivalent to diffusers.VaeImageProcessor.denormalize
											a__     						=(sample / 2 + 0.5).clamp(0					,     1)
											if output_type == "pt":
																		return sample

											# Equivalent to diffusers.VaeImageProcessor.pt_to_numpy
											a__     						=sample.cpu().permute(0					,     2					,     3					,     1).numpy()
											if output_type == "np":
																		return sample

											# Output_type must be 'pil'
											a__     						=self.numpy_to_pil(lowercase_)
											return sample





				def 	__UpperCamelCase						(							self					,     lowercase_					,     lowercase_					,     lowercase_=None)     ->   Optional[int]:
											if self.unet.config.num_class_embeds is not None:
																		if isinstance(lowercase_					,     lowercase_):
																									a__     						=torch.tensor(lowercase_					,     dtype=torch.int)
																		elif isinstance(lowercase_					,     lowercase_):
																									assert batch_size == 1, "Batch size must be 1 if classes is an int"
																									a__     						=torch.tensor([class_labels]					,     dtype=torch.int)
																		elif class_labels is None:
																									# Randomly generate batch_size class labels
																									# TODO: should use generator here? int analogue of randn_tensor is not exposed in ...utils
																									a__     						=torch.randint(0					,     self.unet.config.num_class_embeds					,     size=(batch_size,))
																		a__     						=class_labels.to(lowercase_)
											else:
																		a__     						=None
											return class_labels





				def 	__UpperCamelCase						(							self					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_)     ->   Dict:
											if num_inference_steps is None and timesteps is None:
																		raise ValueError('Exactly one of `num_inference_steps` or `timesteps` must be supplied.')

											if num_inference_steps is not None and timesteps is not None:
																		logger.warning(
																		    F"""Both `num_inference_steps`: {num_inference_steps} and `timesteps`: {timesteps} are supplied;"""
																		    ' `timesteps` will be used over `num_inference_steps`.')

											if latents is not None:
																		a__     						=(batch_size, 3, img_size, img_size)
																		if latents.shape != expected_shape:
																									raise ValueError(F"""The shape of latents is {latents.shape} but is expected to be {expected_shape}.""")

											if (callback_steps is None) or (
											    callback_steps is not None and (not isinstance(lowercase_					,     lowercase_) or callback_steps <= 0)
											):
																		raise ValueError(
																		    F"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
																		    F""" {type(lowercase_)}.""")





				@torch.no_grad()
				@replace_example_docstring(lowercase_)
				def __call__(							self					,     lowercase_ = 1					,     lowercase_ = None					,     lowercase_ = 1					,     lowercase_ = None					,     lowercase_ = None					,     lowercase_ = None					,     lowercase_ = "pil"					,     lowercase_ = True					,     lowercase_ = None					,     lowercase_ = 1					,     )     ->   Any:
											a__     						=self.unet.config.sample_size
											a__     						=self._execution_device

											# 1. Check inputs
											self.check_inputs(lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_					,     lowercase_)

											# 2. Prepare image latents
											# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
											a__     						=self.prepare_latents(
											    batch_size=lowercase_					,     num_channels=self.unet.config.in_channels					,     height=lowercase_					,     width=lowercase_					,     dtype=self.unet.dtype					,     device=lowercase_					,     generator=lowercase_					,     latents=lowercase_					,     )

											# 3. Handle class_labels for class-conditional models
											a__     						=self.prepare_class_labels(lowercase_					,     lowercase_					,     class_labels=lowercase_)

											# 4. Prepare timesteps
											if timesteps is not None:
																		self.scheduler.set_timesteps(timesteps=lowercase_					,     device=lowercase_)
																		a__     						=self.scheduler.timesteps
																		a__     						=len(lowercase_)
											else:
																		self.scheduler.set_timesteps(lowercase_)
																		a__     						=self.scheduler.timesteps

											# 5. Denoising loop
											# Multistep sampling: implements Algorithm 1 in the paper
											with self.progress_bar(total=lowercase_) as progress_bar:
																		for i, t in enumerate(lowercase_):
																									a__     						=self.scheduler.scale_model_input(lowercase_					,     lowercase_)
																									a__     						=self.unet(lowercase_					,     lowercase_					,     class_labels=lowercase_					,     return_dict=lowercase_)[0]

																									a__     						=self.scheduler.step(lowercase_					,     lowercase_					,     lowercase_					,     generator=lowercase_)[0]

																									# call the callback, if provided
																									progress_bar.update()
																									if callback is not None and i % callback_steps == 0:
																																callback(lowercase_					,     lowercase_					,     lowercase_)

        # 6. Post-process image sample
											a__     						=self.postprocess_image(lowercase_					,     output_type=lowercase_)

											# Offload last model to CPU
											if hasattr(self					,     'final_offload_hook') and self.final_offload_hook is not None:
																		self.final_offload_hook.offload()

											if not return_dict:
																		return (image,)

											return ImagePipelineOutput(images=lowercase_)





import os

import requests

_lowerCAmelCase:	int      							=					'https://www.amdoren.com/api/currency.php'


# Currency and their description
_lowerCAmelCase:	Dict      							=					'\nAED	United Arab Emirates Dirham\nAFN	Afghan Afghani\nALL	Albanian Lek\nAMD	Armenian Dram\nANG	Netherlands Antillean Guilder\nAOA	Angolan Kwanza\nARS	Argentine Peso\nAUD	Australian Dollar\nAWG	Aruban Florin\nAZN	Azerbaijani Manat\nBAM	Bosnia & Herzegovina Convertible Mark\nBBD	Barbadian Dollar\nBDT	Bangladeshi Taka\nBGN	Bulgarian Lev\nBHD	Bahraini Dinar\nBIF	Burundian Franc\nBMD	Bermudian Dollar\nBND	Brunei Dollar\nBOB	Bolivian Boliviano\nBRL	Brazilian Real\nBSD	Bahamian Dollar\nBTN	Bhutanese Ngultrum\nBWP	Botswana Pula\nBYN	Belarus Ruble\nBZD	Belize Dollar\nCAD	Canadian Dollar\nCDF	Congolese Franc\nCHF	Swiss Franc\nCLP	Chilean Peso\nCNY	Chinese Yuan\nCOP	Colombian Peso\nCRC	Costa Rican Colon\nCUC	Cuban Convertible Peso\nCVE	Cape Verdean Escudo\nCZK	Czech Republic Koruna\nDJF	Djiboutian Franc\nDKK	Danish Krone\nDOP	Dominican Peso\nDZD	Algerian Dinar\nEGP	Egyptian Pound\nERN	Eritrean Nakfa\nETB	Ethiopian Birr\nEUR	Euro\nFJD	Fiji Dollar\nGBP	British Pound Sterling\nGEL	Georgian Lari\nGHS	Ghanaian Cedi\nGIP	Gibraltar Pound\nGMD	Gambian Dalasi\nGNF	Guinea Franc\nGTQ	Guatemalan Quetzal\nGYD	Guyanaese Dollar\nHKD	Hong Kong Dollar\nHNL	Honduran Lempira\nHRK	Croatian Kuna\nHTG	Haiti Gourde\nHUF	Hungarian Forint\nIDR	Indonesian Rupiah\nILS	Israeli Shekel\nINR	Indian Rupee\nIQD	Iraqi Dinar\nIRR	Iranian Rial\nISK	Icelandic Krona\nJMD	Jamaican Dollar\nJOD	Jordanian Dinar\nJPY	Japanese Yen\nKES	Kenyan Shilling\nKGS	Kyrgystani Som\nKHR	Cambodian Riel\nKMF	Comorian Franc\nKPW	North Korean Won\nKRW	South Korean Won\nKWD	Kuwaiti Dinar\nKYD	Cayman Islands Dollar\nKZT	Kazakhstan Tenge\nLAK	Laotian Kip\nLBP	Lebanese Pound\nLKR	Sri Lankan Rupee\nLRD	Liberian Dollar\nLSL	Lesotho Loti\nLYD	Libyan Dinar\nMAD	Moroccan Dirham\nMDL	Moldovan Leu\nMGA	Malagasy Ariary\nMKD	Macedonian Denar\nMMK	Myanma Kyat\nMNT	Mongolian Tugrik\nMOP	Macau Pataca\nMRO	Mauritanian Ouguiya\nMUR	Mauritian Rupee\nMVR	Maldivian Rufiyaa\nMWK	Malawi Kwacha\nMXN	Mexican Peso\nMYR	Malaysian Ringgit\nMZN	Mozambican Metical\nNAD	Namibian Dollar\nNGN	Nigerian Naira\nNIO	Nicaragua Cordoba\nNOK	Norwegian Krone\nNPR	Nepalese Rupee\nNZD	New Zealand Dollar\nOMR	Omani Rial\nPAB	Panamanian Balboa\nPEN	Peruvian Nuevo Sol\nPGK	Papua New Guinean Kina\nPHP	Philippine Peso\nPKR	Pakistani Rupee\nPLN	Polish Zloty\nPYG	Paraguayan Guarani\nQAR	Qatari Riyal\nRON	Romanian Leu\nRSD	Serbian Dinar\nRUB	Russian Ruble\nRWF	Rwanda Franc\nSAR	Saudi Riyal\nSBD	Solomon Islands Dollar\nSCR	Seychellois Rupee\nSDG	Sudanese Pound\nSEK	Swedish Krona\nSGD	Singapore Dollar\nSHP	Saint Helena Pound\nSLL	Sierra Leonean Leone\nSOS	Somali Shilling\nSRD	Surinamese Dollar\nSSP	South Sudanese Pound\nSTD	Sao Tome and Principe Dobra\nSYP	Syrian Pound\nSZL	Swazi Lilangeni\nTHB	Thai Baht\nTJS	Tajikistan Somoni\nTMT	Turkmenistani Manat\nTND	Tunisian Dinar\nTOP	Tonga Paanga\nTRY	Turkish Lira\nTTD	Trinidad and Tobago Dollar\nTWD	New Taiwan Dollar\nTZS	Tanzanian Shilling\nUAH	Ukrainian Hryvnia\nUGX	Ugandan Shilling\nUSD	United States Dollar\nUYU	Uruguayan Peso\nUZS	Uzbekistan Som\nVEF	Venezuelan Bolivar\nVND	Vietnamese Dong\nVUV	Vanuatu Vatu\nWST	Samoan Tala\nXAF	Central African CFA franc\nXCD	East Caribbean Dollar\nXOF	West African CFA franc\nXPF	CFP Franc\nYER	Yemeni Rial\nZAR	South African Rand\nZMW	Zambian Kwacha\n'






def      _lowercase(				__a							:	str = "USD"						,    __a							:	str = "INR"						,    __a							:	float = 1.0						,    __a							:	str = ""    ):
							a__     						=locals()
							# from is a reserved keyword
							a__     						=params.pop('from_'    )
							a__     						=requests.get(__a						,    params=__a    ).json()
							return str(res['amount']    ) if res["error"] == 0 else res["error_message"]


if __name__ == "__main__":
	_lowerCAmelCase:	Union[str, Any]      							=					os.getenv('CI', '')
	_lowerCAmelCase:	Optional[Any]      							=					os.getenv('AMDOREN_API_KEY', '')

	if not API_KEY and not TESTING:
		raise KeyError(
		    'API key must be provided in the \'AMDOREN_API_KEY\' environment variable.'
		)

	print(
	    convert_currency(
	        input('Enter from currency: ').strip(),
	        input('Enter to currency: ').strip(),
	        float(input('Enter the amount: ').strip()),
	        API_KEY,
	    )
	)

