

import os

import requests

UpperCamelCase__     :					Union[str, Any]								=			"https://www.amdoren.com/api/currency.php"


# Currency and their description
UpperCamelCase__     :					List[str]								=			"\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     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						str = "USD"       ,      _SCREAMING_SNAKE_CASE    :						str = "INR"       ,      _SCREAMING_SNAKE_CASE    :						float = 1.0       ,      _SCREAMING_SNAKE_CASE    :						str = ""				):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  locals()
    # from is a reserved keyword
    SCREAMING_SNAKE_CASE_													=  params.pop('from_'				)
    SCREAMING_SNAKE_CASE_													=  requests.get(_SCREAMING_SNAKE_CASE       ,      params=_SCREAMING_SNAKE_CASE				).json()
    return str(res['amount']				) if res["error"] == 0 else res["error_message"]


if __name__ == "__main__":
       UpperCamelCase__     :					Tuple								=			os.getenv("CI", "")
       UpperCamelCase__     :					Dict								=			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,
           )
       )





from dataclasses import dataclass
from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..models.embeddings import ImagePositionalEmbeddings
from ..utils import BaseOutput, deprecate
from .attention import BasicTransformerBlock
from .embeddings import PatchEmbed
from .modeling_utils import ModelMixin



@dataclass
class 					__snake_case     (			lowerCAmelCase__				):
  __lowerCAmelCase   :		torch.FloatTensor






class 					__snake_case     (			lowerCAmelCase__   ,       lowerCAmelCase__				):

  @register_to_config
  def __init__(    self  ,						_A = 16  ,						_A = 88  ,						_A = None  ,						_A = None  ,						_A = 1  ,						_A = 0.0  ,						_A = 32  ,						_A = None  ,						_A = False  ,						_A = None  ,						_A = None  ,						_A = None  ,						_A = "geglu"  ,						_A = None  ,						_A = False  ,						_A = False  ,						_A = False  ,						_A = "layer_norm"  ,						_A = True  ,						):
      super().__init__()
      SCREAMING_SNAKE_CASE_													=  use_linear_projection
      SCREAMING_SNAKE_CASE_													=  num_attention_heads
      SCREAMING_SNAKE_CASE_													=  attention_head_dim
      SCREAMING_SNAKE_CASE_													=  num_attention_heads * attention_head_dim

      # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
      # Define whether input is continuous or discrete depending on configuration
      SCREAMING_SNAKE_CASE_													=  (in_channels is not None) and (patch_size is None)
      SCREAMING_SNAKE_CASE_													=  num_vector_embeds is not None
      SCREAMING_SNAKE_CASE_													=  in_channels is not None and patch_size is not None

      if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
          SCREAMING_SNAKE_CASE_													=  (
              f"""The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"""
              ' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'
              ' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'
              ' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'
              ' would be very nice if you could open a Pull request for the `transformer/config.json` file'
          )
          deprecate('norm_type!=num_embeds_ada_norm'  ,						'1.0.0'  ,						_A  ,						standard_warn=_A)
          SCREAMING_SNAKE_CASE_													=  'ada_norm'

      if self.is_input_continuous and self.is_input_vectorized:
          raise ValueError(
              f"""Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"""
              ' sure that either `in_channels` or `num_vector_embeds` is None.')
      elif self.is_input_vectorized and self.is_input_patches:
          raise ValueError(
              f"""Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"""
              ' sure that either `num_vector_embeds` or `num_patches` is None.')
      elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
          raise ValueError(
              f"""Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"""
              f""" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None.""")

      # 2. Define input layers
      if self.is_input_continuous:
          SCREAMING_SNAKE_CASE_													=  in_channels

          SCREAMING_SNAKE_CASE_													=  torch.nn.GroupNorm(num_groups=_A  ,						num_channels=_A  ,						eps=1E-6  ,						affine=_A)
          if use_linear_projection:
              SCREAMING_SNAKE_CASE_													=  nn.Linear(_A  ,						_A)
          else:
              SCREAMING_SNAKE_CASE_													=  nn.Convad(_A  ,						_A  ,						kernel_size=1  ,						stride=1  ,						padding=0)
      elif self.is_input_vectorized:
          assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
          assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"

          SCREAMING_SNAKE_CASE_													=  sample_size
          SCREAMING_SNAKE_CASE_													=  sample_size
          SCREAMING_SNAKE_CASE_													=  num_vector_embeds
          SCREAMING_SNAKE_CASE_													=  self.height * self.width

          SCREAMING_SNAKE_CASE_													=  ImagePositionalEmbeddings(
              num_embed=_A  ,						embed_dim=_A  ,						height=self.height  ,						width=self.width)
      elif self.is_input_patches:
          assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"

          SCREAMING_SNAKE_CASE_													=  sample_size
          SCREAMING_SNAKE_CASE_													=  sample_size

          SCREAMING_SNAKE_CASE_													=  patch_size
          SCREAMING_SNAKE_CASE_													=  PatchEmbed(
              height=_A  ,						width=_A  ,						patch_size=_A  ,						in_channels=_A  ,						embed_dim=_A  ,						)

      # 3. Define transformers blocks
      SCREAMING_SNAKE_CASE_													=  nn.ModuleList(
          [
              BasicTransformerBlock(
                  _A  ,						_A  ,						_A  ,						dropout=_A  ,						cross_attention_dim=_A  ,						activation_fn=_A  ,						num_embeds_ada_norm=_A  ,						attention_bias=_A  ,						only_cross_attention=_A  ,						upcast_attention=_A  ,						norm_type=_A  ,						norm_elementwise_affine=_A  ,						)
              for d in range(_A)
          ])

      # 4. Define output layers
      SCREAMING_SNAKE_CASE_													=  in_channels if out_channels is None else out_channels
      if self.is_input_continuous:
          # TODO: should use out_channels for continuous projections
          if use_linear_projection:
              SCREAMING_SNAKE_CASE_													=  nn.Linear(_A  ,						_A)
          else:
              SCREAMING_SNAKE_CASE_													=  nn.Convad(_A  ,						_A  ,						kernel_size=1  ,						stride=1  ,						padding=0)
      elif self.is_input_vectorized:
          SCREAMING_SNAKE_CASE_													=  nn.LayerNorm(_A)
          SCREAMING_SNAKE_CASE_													=  nn.Linear(_A  ,						self.num_vector_embeds - 1)
      elif self.is_input_patches:
          SCREAMING_SNAKE_CASE_													=  nn.LayerNorm(_A  ,						elementwise_affine=_A  ,						eps=1E-6)
          SCREAMING_SNAKE_CASE_													=  nn.Linear(_A  ,						2 * inner_dim)
          SCREAMING_SNAKE_CASE_													=  nn.Linear(_A  ,						patch_size * patch_size * self.out_channels)


  def   lowerCAmelCase__   (    self  ,						_A  ,						_A = None  ,						_A = None  ,						_A = None  ,						_A = None  ,						_A = None  ,						_A = None  ,						_A = True  ,						):
      # ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
      #   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
      #   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
      # expects mask of shape:
      #   [batch, key_tokens]
      # adds singleton query_tokens dimension:
      #   [batch,                    1, key_tokens]
      # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
      #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
      #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
      if attention_mask is not None and attention_mask.ndim == 2:
          # assume that mask is expressed as:
          #   (1 = keep,      0 = discard)
          # convert mask into a bias that can be added to attention scores:
          #       (keep = +0,     discard = -10000.0)
          SCREAMING_SNAKE_CASE_													=  (1 - attention_mask.to(hidden_states.dtype)) * -1_0_0_0_0.0
          SCREAMING_SNAKE_CASE_													=  attention_mask.unsqueeze(1)

      # convert encoder_attention_mask to a bias the same way we do for attention_mask
      if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
          SCREAMING_SNAKE_CASE_													=  (1 - encoder_attention_mask.to(hidden_states.dtype)) * -1_0_0_0_0.0
          SCREAMING_SNAKE_CASE_													=  encoder_attention_mask.unsqueeze(1)

      # 1. Input
      if self.is_input_continuous:
          SCREAMING_SNAKE_CASE_							,	SCREAMING_SNAKE_CASE_							,	SCREAMING_SNAKE_CASE_							,	SCREAMING_SNAKE_CASE_													=  hidden_states.shape
          SCREAMING_SNAKE_CASE_													=  hidden_states

          SCREAMING_SNAKE_CASE_													=  self.norm(_A)
          if not self.use_linear_projection:
              SCREAMING_SNAKE_CASE_													=  self.proj_in(_A)
              SCREAMING_SNAKE_CASE_													=  hidden_states.shape[1]
              SCREAMING_SNAKE_CASE_													=  hidden_states.permute(0  ,						2  ,						3  ,						1).reshape(_A  ,						height * width  ,						_A)
          else:
              SCREAMING_SNAKE_CASE_													=  hidden_states.shape[1]
              SCREAMING_SNAKE_CASE_													=  hidden_states.permute(0  ,						2  ,						3  ,						1).reshape(_A  ,						height * width  ,						_A)
              SCREAMING_SNAKE_CASE_													=  self.proj_in(_A)
      elif self.is_input_vectorized:
          SCREAMING_SNAKE_CASE_													=  self.latent_image_embedding(_A)
      elif self.is_input_patches:
          SCREAMING_SNAKE_CASE_													=  self.pos_embed(_A)

      # 2. Blocks
      for block in self.transformer_blocks:
          SCREAMING_SNAKE_CASE_													=  block(
              _A  ,						attention_mask=_A  ,						encoder_hidden_states=_A  ,						encoder_attention_mask=_A  ,						timestep=_A  ,						cross_attention_kwargs=_A  ,						class_labels=_A  ,						)

      # 3. Output
      if self.is_input_continuous:
          if not self.use_linear_projection:
              SCREAMING_SNAKE_CASE_													=  hidden_states.reshape(_A  ,						_A  ,						_A  ,						_A).permute(0  ,						3  ,						1  ,						2).contiguous()
              SCREAMING_SNAKE_CASE_													=  self.proj_out(_A)
          else:
              SCREAMING_SNAKE_CASE_													=  self.proj_out(_A)
              SCREAMING_SNAKE_CASE_													=  hidden_states.reshape(_A  ,						_A  ,						_A  ,						_A).permute(0  ,						3  ,						1  ,						2).contiguous()

          SCREAMING_SNAKE_CASE_													=  hidden_states + residual
      elif self.is_input_vectorized:
          SCREAMING_SNAKE_CASE_													=  self.norm_out(_A)
          SCREAMING_SNAKE_CASE_													=  self.out(_A)
          # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
          SCREAMING_SNAKE_CASE_													=  logits.permute(0  ,						2  ,						1)

          # log(p(x_0))
          SCREAMING_SNAKE_CASE_													=  F.log_softmax(logits.double()  ,						dim=1).float()
      elif self.is_input_patches:
          # TODO: cleanup!
          SCREAMING_SNAKE_CASE_													=  self.transformer_blocks[0].norma.emb(
              _A  ,						_A  ,						hidden_dtype=hidden_states.dtype)
          SCREAMING_SNAKE_CASE_							,	SCREAMING_SNAKE_CASE_													=  self.proj_out_a(F.silu(_A)).chunk(2  ,						dim=1)
          SCREAMING_SNAKE_CASE_													=  self.norm_out(_A) * (1 + scale[:, None]) + shift[:, None]
          SCREAMING_SNAKE_CASE_													=  self.proj_out_a(_A)

          # unpatchify
          SCREAMING_SNAKE_CASE_													=  SCREAMING_SNAKE_CASE_													=  int(hidden_states.shape[1] ** 0.5)
          SCREAMING_SNAKE_CASE_													=  hidden_states.reshape(
              shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels))
          SCREAMING_SNAKE_CASE_													=  torch.einsum('nhwpqc->nchpwq'  ,						_A)
          SCREAMING_SNAKE_CASE_													=  hidden_states.reshape(
              shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size))

      if not return_dict:
          return (output,)

      return TransformeraDModelOutput(sample=_A)


