code: def config_list_openai_aoai(
      key_file_path: Optional[str] = ".",
      openai_api_key_file: Optional[str] = "key_openai.txt",
      aoai_api_key_file: Optional[str] = "key_aoai.txt",
      openai_api_base_file: Optional[str] = "base_openai.txt",
      aoai_api_base_file: Optional[str] = "base_aoai.txt",
      exclude: Optional[str] = None,
  ) -> List[Dict]:
      """Get a list of configs for OpenAI API client (including Azure or local model deployments that support OpenAI's chat completion API).
  
      This function constructs configurations by reading API keys and base URLs from environment variables or text files.
      It supports configurations for both OpenAI and Azure OpenAI services, allowing for the exclusion of one or the other.
      When text files are used, the environment variables will be overwritten.
      To prevent text files from being used, set the corresponding file name to None.
      Or set key_file_path to None to disallow reading from text files.
  
      Args:
          key_file_path (str, optional): The directory path where the API key files are located. Defaults to the current directory.
          openai_api_key_file (str, optional): The filename containing the OpenAI API key. Defaults to 'key_openai.txt'.
          aoai_api_key_file (str, optional): The filename containing the Azure OpenAI API key. Defaults to 'key_aoai.txt'.
          openai_api_base_file (str, optional): The filename containing the OpenAI API base URL. Defaults to 'base_openai.txt'.
          aoai_api_base_file (str, optional): The filename containing the Azure OpenAI API base URL. Defaults to 'base_aoai.txt'.
          exclude (str, optional): The API type to exclude from the configuration list. Can be 'openai' or 'aoai'. Defaults to None.
  
      Returns:
          List[Dict]: A list of configuration dictionaries. Each dictionary contains keys for 'api_key',
              and optionally 'base_url', 'api_type', and 'api_version'.
  
      Raises:
          FileNotFoundError: If the specified key files are not found and the corresponding API key is not set in the environment variables.
  
      Example:
          # To generate configurations excluding Azure OpenAI:
          configs = config_list_openai_aoai(exclude='aoai')
  
      File samples:
          - key_aoai.txt
  
          ```
          aoai-12345abcdef67890ghijklmnopqr
          aoai-09876zyxwvuts54321fedcba
          ```
  
          - base_aoai.txt
  
          ```
          https://api.azure.com/v1
          https://api.azure2.com/v1
          ```
  
      Notes:
          - The function checks for API keys and base URLs in the following environment variables: 'OPENAI_API_KEY', 'AZURE_OPENAI_API_KEY',
            'OPENAI_API_BASE' and 'AZURE_OPENAI_API_BASE'. If these are not found, it attempts to read from the specified files in the
            'key_file_path' directory.
          - The API version for Azure configurations is set to DEFAULT_AZURE_API_VERSION by default.
          - If 'exclude' is set to 'openai', only Azure OpenAI configurations are returned, and vice versa.
          - The function assumes that the API keys and base URLs in the environment variables are separated by new lines if there are
            multiple entries.
      """
      if exclude != "openai" and key_file_path is not None:
          # skip if key_file_path is None
          if openai_api_key_file is not None:
              # skip if openai_api_key_file is None
              try:
                  with open(
                      f"{key_file_path}/{openai_api_key_file}"
                  ) as key_file:
                      os.environ[
                          "OPENAI_API_KEY"
                      ] = key_file.read().strip()
              except FileNotFoundError:
                  logging.info(
                      "OPENAI_API_KEY is not found in os.environ "
                      "and key_openai.txt is not found in the specified path. You can specify the api_key in the config_list."
                  )
          if openai_api_base_file is not None:
              # skip if openai_api_base_file is None
              try:
                  with open(
                      f"{key_file_path}/{openai_api_base_file}"
                  ) as key_file:
                      os.environ[
                          "OPENAI_API_BASE"
                      ] = key_file.read().strip()
              except FileNotFoundError:
                  logging.info(
                      "OPENAI_API_BASE is not found in os.environ "
                      "and base_openai.txt is not found in the specified path. You can specify the base_url in the config_list."
                  )
      if exclude != "aoai" and key_file_path is not None:
          # skip if key_file_path is None
          if aoai_api_key_file is not None:
              try:
                  with open(
                      f"{key_file_path}/{aoai_api_key_file}"
                  ) as key_file:
                      os.environ[
                          "AZURE_OPENAI_API_KEY"
                      ] = key_file.read().strip()
              except FileNotFoundError:
                  logging.info(
                      "AZURE_OPENAI_API_KEY is not found in os.environ "
                      "and key_aoai.txt is not found in the specified path. You can specify the api_key in the config_list."
                  )
          if aoai_api_base_file is not None:
              try:
                  with open(
                      f"{key_file_path}/{aoai_api_base_file}"
                  ) as key_file:
                      os.environ[
                          "AZURE_OPENAI_API_BASE"
                      ] = key_file.read().strip()
              except FileNotFoundError:
                  logging.info(
                      "AZURE_OPENAI_API_BASE is not found in os.environ "
                      "and base_aoai.txt is not found in the specified path. You can specify the base_url in the config_list."
                  )
      aoai_config = (
          get_config_list(
              # Assuming Azure OpenAI api keys in os.environ["AZURE_OPENAI_API_KEY"], in separated lines
              api_keys=os.environ.get("AZURE_OPENAI_API_KEY", "").split(
                  "\n"
              ),
              # Assuming Azure OpenAI api bases in os.environ["AZURE_OPENAI_API_BASE"], in separated lines
              base_urls=os.environ.get(
                  "AZURE_OPENAI_API_BASE", ""
              ).split("\n"),
              api_type="azure",
              api_version=DEFAULT_AZURE_API_VERSION,
          )
          if exclude != "aoai"
          else []
      )
      # process openai base urls
      base_urls = os.environ.get("OPENAI_API_BASE", None)
      base_urls = (
          base_urls if base_urls is None else base_urls.split("\n")
      )
      openai_config = (
          get_config_list(
              # Assuming OpenAI API_KEY in os.environ["OPENAI_API_KEY"]
              api_keys=os.environ.get("OPENAI_API_KEY", "").split("\n"),
              base_urls=base_urls,
          )
          if exclude != "openai"
          else []
      )
      config_list = openai_config + aoai_config
      return config_list
  
file_path: autogen/autogen/oai/openai_utils.py
imports: import json
  import logging
  import os
  import tempfile
  from pathlib import Path
  from typing import Any, Dict, List, Optional, Set, Union
  from dotenv import find_dotenv, load_dotenv
label_desc: Use image node_id 3 for calling a global function with example usage: config_list_openai_aoai(key_file_path, openai_api_key_file, aoai_api_key_file, openai_api_base_file, aoai_api_base_file, exclude) and returns: config_list