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: Try calling the model 3 times. Shuffle between available deployments.
code: def function_with_retries(self, *args, **kwargs):
      """
      Try calling the model 3 times. Shuffle between available deployments.
      """
      verbose_router_logger.debug(
          f"Inside function with retries: args - {args}; kwargs - {kwargs}"
      )
      original_function = kwargs.pop("original_function")
      num_retries = kwargs.pop("num_retries")
      fallbacks = kwargs.pop("fallbacks", self.fallbacks)
      context_window_fallbacks = kwargs.pop(
          "context_window_fallbacks", self.context_window_fallbacks
      )
      try:
          # if the function call is successful, no exception will be raised and we'll break out of the loop
          response = original_function(*args, **kwargs)
          return response
      except Exception as e:
          original_exception = e
          verbose_router_logger.debug(
              f"num retries in function with retries: {num_retries}"
          )
          ### CHECK IF RATE LIMIT / CONTEXT WINDOW ERROR
          if (
              isinstance(
                  original_exception, litellm.ContextWindowExceededError
              )
              and context_window_fallbacks is None
          ) or (
              isinstance(original_exception, openai.RateLimitError)
              and fallbacks is not None
          ):
              raise original_exception
          ## LOGGING
          if num_retries > 0:
              kwargs = self.log_retry(
                  kwargs=kwargs, e=original_exception
              )
          ### RETRY
          for current_attempt in range(num_retries):
              verbose_router_logger.debug(
                  f"retrying request. Current attempt - {current_attempt}; retries left: {num_retries}"
              )
              try:
                  # if the function call is successful, no exception will be raised and we'll break out of the loop
                  response = original_function(*args, **kwargs)
                  return response
  
              except Exception as e:
                  ## LOGGING
                  kwargs = self.log_retry(kwargs=kwargs, e=e)
                  remaining_retries = num_retries - current_attempt
                  if "No models available" in str(e):
                      timeout = litellm._calculate_retry_after(
                          remaining_retries=remaining_retries,
                          max_retries=num_retries,
                          min_timeout=self.retry_after,
                      )
                      time.sleep(timeout)
                  elif (
                      hasattr(e, "status_code")
                      and hasattr(e, "response")
                      and litellm._should_retry(
                          status_code=e.status_code
                      )
                  ):
                      if hasattr(e.response, "headers"):
                          timeout = litellm._calculate_retry_after(
                              remaining_retries=remaining_retries,
                              max_retries=num_retries,
                              response_headers=e.response.headers,
                              min_timeout=self.retry_after,
                          )
                      else:
                          timeout = litellm._calculate_retry_after(
                              remaining_retries=remaining_retries,
                              max_retries=num_retries,
                              min_timeout=self.retry_after,
                          )
                      time.sleep(timeout)
                  else:
                      raise e
          raise original_exception
  
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 9 for calling the Router obj's underlying member method code with example usage: obj.function_with_retries() and returns: response, response