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: Add a model to the list of models being cooled down for that minute, if it exceeds the allowed fails / minute
code: def _set_cooldown_deployments(self, deployment: Optional[str] = None):
      """
      Add a model to the list of models being cooled down for that minute, if it exceeds the allowed fails / minute
      """
      if deployment is None:
          return
  
      current_minute = datetime.now().strftime("%H-%M")
      # get current fails for deployment
      # update the number of failed calls
      # if it's > allowed fails
      # cooldown deployment
      current_fails = self.failed_calls.get_cache(key=deployment) or 0
      updated_fails = current_fails + 1
      verbose_router_logger.debug(
          f"Attempting to add {deployment} to cooldown list. updated_fails: {updated_fails}; self.allowed_fails: {self.allowed_fails}"
      )
      if updated_fails > self.allowed_fails:
          # get the current cooldown list for that minute
          cooldown_key = f"{current_minute}:cooldown_models"  # group cooldown models by minute to reduce number of redis calls
          cached_value = self.cache.get_cache(key=cooldown_key)
  
          verbose_router_logger.debug(
              f"adding {deployment} to cooldown models"
          )
          # update value
          try:
              if deployment in cached_value:
                  pass
              else:
                  cached_value = cached_value + [deployment]
                  # save updated value
                  self.cache.set_cache(
                      value=cached_value, key=cooldown_key, ttl=1
                  )
          except:
              cached_value = [deployment]
              # save updated value
              self.cache.set_cache(
                  value=cached_value, key=cooldown_key, ttl=1
              )
      else:
          self.failed_calls.set_cache(
              key=deployment, value=updated_fails, ttl=1
          )
  
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 12 for calling the Router obj's underlying member method code with example usage: obj._set_cooldown_deployments(deployment) without return types