Chart cache warmup fails with 405 Method Not Allowed about superset HOT 2 OPEN

@expose("/warm_up_cache", methods=("PUT",))
@protect()
@safe
@statsd_metrics
@event_logger.log_this_with_context(
    action=lambda self, *args, **kwargs: f"{self.__class__.__name__}"
    f".warm_up_cache",
    log_to_statsd=False,
)
def warm_up_cache(self) -> Response:
    """Warm up the cache for the chart.
    ---
    put:
      summary: Warm up the cache for the chart
      description: >-
        Warms up the cache for the chart.
        Note for slices a force refresh occurs.
        In terms of the `extra_filters` these can be obtained from records in the JSON
        encoded `logs.json` column associated with the `explore_json` action.
      requestBody:
        description: >-
          Identifies the chart to warm up cache for, and any additional dashboard or
          filter context to use.
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ChartCacheWarmUpRequestSchema"
      responses:
        200:
          description: Each chart's warmup status
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ChartCacheWarmUpResponseSchema"
        400:
          $ref: '#/components/responses/400'
        404:
          $ref: '#/components/responses/404'
        500:
          $ref: '#/components/responses/500'
    """
    try:
        body = ChartCacheWarmUpRequestSchema().load(request.json)
    except ValidationError as error:
        return self.response_400(message=error.messages)
    try:
        result = ChartWarmUpCacheCommand(
            body["chart_id"],
            body.get("dashboard_id"),
            body.get("extra_filters"),
        ).run()
        return self.response(200, result=[result])
    except CommandException as ex:
        return self.response(ex.status, message=ex.message)

import requests

url = "http://your-superset-url/api/v1/chart/warm_up_cache"
data = {
    "chart_id": 1,
    "dashboard_id": 2,
    "extra_filters": []
}
headers = {
    "Content-Type": "application/json"
}

response = requests.put(url, json=data, headers=headers)
print(response.status_code, response.json())

@celery_app.task(name="fetch_url")
def fetch_url(data: str, headers: dict[str, str]) -> dict[str, str]:
    """
    Celery job to fetch url
    """
    result = {}
    try:
        url = get_url_path("Superset.warm_up_cache")
        logger.info("Fetching %s with payload %s", url, data)
        req = request.Request(
            url, data=bytes(data, "utf-8"), headers=headers, method="PUT"
        )
        response = request.urlopen(  # pylint: disable=consider-using-with
            req, timeout=600
        )
        logger.info(
            "Fetched %s with payload %s, status code: %s", url, data, response.code
        )
        if response.code == 200:
            result = {"success": data, "response": response.read().decode("utf-8")}
        else:
            result = {"error": data, "status_code": response.code}
            logger.error(
                "Error fetching %s with payload %s, status code: %s",
                url,
                data,
                response.code,
            )
    except URLError as err:
        logger.exception("Error warming up cache!")
        result = {"error": data, "exception": str(err)}
    return result