code: def embedding(
      self,
      model: str,
      input: list,
      api_key: str,
      api_base: str,
      api_version: str,
      timeout: float,
      logging_obj=None,
      model_response=None,
      optional_params=None,
      azure_ad_token: Optional[str] = None,
      client=None,
      aembedding=None,
  ):
      super().embedding()
      exception_mapping_worked = False
      if self._client_session is None:
          self._client_session = self.create_client_session()
      try:
          data = {"model": model, "input": input, **optional_params}
          max_retries = data.pop("max_retries", 2)
          if not isinstance(max_retries, int):
              raise AzureOpenAIError(
                  status_code=422, message="max retries must be an int"
              )
  
          # init AzureOpenAI Client
          azure_client_params = {
              "api_version": api_version,
              "azure_endpoint": api_base,
              "azure_deployment": model,
              "http_client": litellm.client_session,
              "max_retries": max_retries,
              "timeout": timeout,
          }
          if api_key is not None:
              azure_client_params["api_key"] = api_key
          elif azure_ad_token is not None:
              azure_client_params["azure_ad_token"] = azure_ad_token
  
          ## LOGGING
          logging_obj.pre_call(
              input=input,
              api_key=api_key,
              additional_args={
                  "complete_input_dict": data,
                  "headers": {
                      "api_key": api_key,
                      "azure_ad_token": azure_ad_token,
                  },
              },
          )
  
          if aembedding == True:
              response = self.aembedding(
                  data=data,
                  input=input,
                  logging_obj=logging_obj,
                  api_key=api_key,
                  model_response=model_response,
                  azure_client_params=azure_client_params,
                  timeout=timeout,
              )
              return response
          if client is None:
              azure_client = AzureOpenAI(**azure_client_params)  # type: ignore
          else:
              azure_client = client
          ## COMPLETION CALL
          response = azure_client.embeddings.create(**data, timeout=timeout)  # type: ignore
          ## LOGGING
          logging_obj.post_call(
              input=input,
              api_key=api_key,
              additional_args={
                  "complete_input_dict": data,
                  "api_base": api_base,
              },
              original_response=response,
          )
  
          return convert_to_model_response_object(response_object=response.model_dump(), model_response_object=model_response, response_type="embedding")  # type: ignore
      except AzureOpenAIError as e:
          exception_mapping_worked = True
          raise e
      except Exception as e:
          if hasattr(e, "status_code"):
              raise AzureOpenAIError(
                  status_code=e.status_code, message=str(e)
              )
          else:
              raise AzureOpenAIError(status_code=500, message=str(e))
  
imports: from typing import Optional, Union, Any
  import types, requests
  from .base import BaseLLM
  from litellm.utils import ModelResponse, Choices, Message, CustomStreamWrapper, convert_to_model_response_object
  from typing import Callable, Optional
  from litellm import OpenAIConfig
  import litellm, json
  import httpx
  from .custom_httpx.azure_dall_e_2 import CustomHTTPTransport, AsyncCustomHTTPTransport
  from openai import AzureOpenAI, AsyncAzureOpenAI
label_desc: Use image node_id 5 for calling the AzureChatCompletion obj's underlying member method code with example usage: obj.embedding(model, input, api_key, api_base, api_version, timeout, logging_obj, model_response, optional_params, azure_ad_token, client, aembedding) and returns: convert_to_model_response_object, response