class_docstr: Example usage:
  ```python
  from litellm import Router
  model_list = [
  {
      "model_name": "azure-gpt-3.5-turbo", # model alias
      "litellm_params": { # params for litellm completion/embedding call
          "model": "azure/<your-deployment-name-1>",
          "api_key": <your-api-key>,
          "api_version": <your-api-version>,
          "api_base": <your-api-base>
      },
  },
  {
      "model_name": "azure-gpt-3.5-turbo", # model alias
      "litellm_params": { # params for litellm completion/embedding call
          "model": "azure/<your-deployment-name-2>",
          "api_key": <your-api-key>,
          "api_version": <your-api-version>,
          "api_base": <your-api-base>
      },
  },
  {
      "model_name": "openai-gpt-3.5-turbo", # model alias
      "litellm_params": { # params for litellm completion/embedding call
          "model": "gpt-3.5-turbo",
          "api_key": <your-api-key>,
      },
  ]
  
  router = Router(model_list=model_list, fallbacks=[{"azure-gpt-3.5-turbo": "openai-gpt-3.5-turbo"}])
  ```
docstr: Returns the deployment based on routing strategy
code: def get_available_deployment(
      self,
      model: str,
      messages: Optional[List[Dict[str, str]]] = None,
      input: Optional[Union[str, List]] = None,
      specific_deployment: Optional[bool] = False,
  ):
      """
      Returns the deployment based on routing strategy
      """
  
      # users need to explicitly call a specific deployment, by setting `specific_deployment = True` as completion()/embedding() kwarg
      # When this was no explicit we had several issues with fallbacks timing out
      if specific_deployment == True:
          # users can also specify a specific deployment name. At this point we should check if they are just trying to call a specific deployment
          for deployment in self.model_list:
              deployment_model = deployment.get("litellm_params").get(
                  "model"
              )
              if deployment_model == model:
                  # User Passed a specific deployment name on their config.yaml, example azure/chat-gpt-v-2
                  # return the first deployment where the `model` matches the specificed deployment name
                  return deployment
          raise ValueError(
              f"LiteLLM Router: Trying to call specific deployment, but Model:{model} does not exist in Model List: {self.model_list}"
          )
  
      # check if aliases set on litellm model alias map
      if model in self.model_group_alias:
          verbose_router_logger.debug(
              f"Using a model alias. Got Request for {model}, sending requests to {self.model_group_alias.get(model)}"
          )
          model = self.model_group_alias[model]
  
      ## get healthy deployments
      ### get all deployments
      healthy_deployments = [
          m for m in self.model_list if m["model_name"] == model
      ]
      if len(healthy_deployments) == 0:
          # check if the user sent in a deployment name instead
          healthy_deployments = [
              m
              for m in self.model_list
              if m["litellm_params"]["model"] == model
          ]
  
      verbose_router_logger.debug(
          f"initial list of deployments: {healthy_deployments}"
      )
  
      # filter out the deployments currently cooling down
      deployments_to_remove = []
      # cooldown_deployments is a list of model_id's cooling down, cooldown_deployments = ["16700539-b3cd-42f4-b426-6a12a1bb706a", "16700539-b3cd-42f4-b426-7899"]
      cooldown_deployments = self._get_cooldown_deployments()
      verbose_router_logger.debug(
          f"cooldown deployments: {cooldown_deployments}"
      )
      # Find deployments in model_list whose model_id is cooling down
      for deployment in healthy_deployments:
          deployment_id = deployment["model_info"]["id"]
          if deployment_id in cooldown_deployments:
              deployments_to_remove.append(deployment)
      # remove unhealthy deployments from healthy deployments
      for deployment in deployments_to_remove:
          healthy_deployments.remove(deployment)
  
      verbose_router_logger.debug(
          f"healthy deployments: length {len(healthy_deployments)} {healthy_deployments}"
      )
      if len(healthy_deployments) == 0:
          raise ValueError("No models available")
      if litellm.model_alias_map and model in litellm.model_alias_map:
          model = litellm.model_alias_map[
              model
          ]  # update the model to the actual value if an alias has been passed in
      if (
          self.routing_strategy == "least-busy"
          and self.leastbusy_logger is not None
      ):
          deployment = self.leastbusy_logger.get_available_deployments(
              model_group=model, healthy_deployments=healthy_deployments
          )
      elif self.routing_strategy == "simple-shuffle":
          # if users pass rpm or tpm, we do a random weighted pick - based on rpm/tpm
          ############## Check if we can do a RPM/TPM based weighted pick #################
          rpm = (
              healthy_deployments[0]
              .get("litellm_params")
              .get("rpm", None)
          )
          if rpm is not None:
              # use weight-random pick if rpms provided
              rpms = [
                  m["litellm_params"].get("rpm", 0)
                  for m in healthy_deployments
              ]
              verbose_router_logger.debug(f"\nrpms {rpms}")
              total_rpm = sum(rpms)
              weights = [rpm / total_rpm for rpm in rpms]
              verbose_router_logger.debug(f"\n weights {weights}")
              # Perform weighted random pick
              selected_index = random.choices(
                  range(len(rpms)), weights=weights
              )[0]
              verbose_router_logger.debug(
                  f"\n selected index, {selected_index}"
              )
              deployment = healthy_deployments[selected_index]
              return deployment or deployment[0]
          ############## Check if we can do a RPM/TPM based weighted pick #################
          tpm = (
              healthy_deployments[0]
              .get("litellm_params")
              .get("tpm", None)
          )
          if tpm is not None:
              # use weight-random pick if rpms provided
              tpms = [
                  m["litellm_params"].get("tpm", 0)
                  for m in healthy_deployments
              ]
              verbose_router_logger.debug(f"\ntpms {tpms}")
              total_tpm = sum(tpms)
              weights = [tpm / total_tpm for tpm in tpms]
              verbose_router_logger.debug(f"\n weights {weights}")
              # Perform weighted random pick
              selected_index = random.choices(
                  range(len(tpms)), weights=weights
              )[0]
              verbose_router_logger.debug(
                  f"\n selected index, {selected_index}"
              )
              deployment = healthy_deployments[selected_index]
              return deployment or deployment[0]
  
          ############## No RPM/TPM passed, we do a random pick #################
          item = random.choice(healthy_deployments)
          return item or item[0]
      elif (
          self.routing_strategy == "latency-based-routing"
          and self.lowestlatency_logger is not None
      ):
          deployment = (
              self.lowestlatency_logger.get_available_deployments(
                  model_group=model,
                  healthy_deployments=healthy_deployments,
              )
          )
      elif (
          self.routing_strategy == "usage-based-routing"
          and self.lowesttpm_logger is not None
      ):
          deployment = self.lowesttpm_logger.get_available_deployments(
              model_group=model,
              healthy_deployments=healthy_deployments,
              messages=messages,
              input=input,
          )
  
      if deployment is None:
          raise ValueError("No models available.")
  
      return deployment
  
imports: import copy, httpx
  from datetime import datetime
  from typing import Dict, List, Optional, Union, Literal, Any
  import random, threading, time, traceback, uuid
  import litellm, openai
  from litellm.caching import RedisCache, InMemoryCache, DualCache
  import logging, asyncio
  import inspect, concurrent
  from openai import AsyncOpenAI
  from collections import defaultdict
  from litellm.router_strategy.least_busy import LeastBusyLoggingHandler
  from litellm.router_strategy.lowest_tpm_rpm import LowestTPMLoggingHandler
  from litellm.router_strategy.lowest_latency import LowestLatencyLoggingHandler
  from litellm.llms.custom_httpx.azure_dall_e_2 import CustomHTTPTransport, AsyncCustomHTTPTransport
  from litellm.utils import ModelResponse, CustomStreamWrapper
  import copy
  from litellm._logging import verbose_router_logger
  import logging
label_desc: Use image node_id 18 for calling the Router obj's underlying member method code with example usage: obj.get_available_deployment(model, messages, input, specific_deployment) and returns: deployment, unknown, deployment, unknown, unknown