code: def create_colormap(palette, img=None):  # noqa: D417
      """Create colormap of the given numpy file, color vector, or colormap.
  
      Args:
          palette (dict): Information describing how to create a colormap
              object. See below for more details.
  
      **From a file**
  
      Colormaps can be loaded from ``.npy``, ``.npz``, or comma-separated text
      files. Numpy (npy/npz) files should be 2D arrays with rows for each color.
      Comma-separated files should have a row for each color with each column
      representing a single value/channel. The filename to load can be provided
      with the ``filename`` key in the provided palette information. A filename
      ending with ``.npy`` or ``.npz`` is read as a numpy file with
      :func:`numpy.load`. All other extensions are
      read as a comma-separated file. For ``.npz`` files the data must be stored
      as a positional list where the first element represents the colormap to
      use. See :func:`numpy.savez` for more information. The path to the
      colormap can be relative if it is stored in a directory specified by
      :ref:`config_path_setting`. Otherwise it should be an absolute path.
  
      The colormap is interpreted as 1 of 4 different "colormap modes":
      ``RGB``, ``RGBA``, ``VRGB``, or ``VRGBA``. The
      colormap mode can be forced with the ``colormap_mode`` key in the provided
      palette information. If it is not provided then a default will be chosen
      based on the number of columns in the array (3: RGB, 4: VRGB, 5: VRGBA).
  
      The "V" in the possible colormap modes represents the control value of
      where that color should be applied. If "V" is not provided in the colormap
      data it defaults to the row index in the colormap array (0, 1, 2, ...)
      divided by the total number of colors to produce a number between 0 and 1.
      See the "Set Range" section below for more information.
      The remaining elements in the colormap array represent the Red (R),
      Green (G), and Blue (B) color to be mapped to.
  
      See the "Color Scale" section below for more information on the value
      range of provided numbers.
  
      **From a list**
  
      Colormaps can be loaded from lists of colors provided by the ``colors``
      key in the provided dictionary. Each element in the list represents a
      single color to be mapped to and can be 3 (RGB) or 4 (RGBA) elements long.
      By default the value or control point for a color is determined by the
      index in the list (0, 1, 2, ...) divided by the total number of colors
      to produce a number between 0 and 1. This can be overridden by providing a
      ``values`` key in the provided dictionary. See the "Set Range" section
      below for more information.
  
      See the "Color Scale" section below for more information on the value
      range of provided numbers.
  
      **From a builtin colormap**
  
      Colormaps can be loaded by name from the builtin colormaps in the
      ``trollimage``` package. Specify the name with the ``colors``
      key in the provided dictionary (ex. ``{'colors': 'blues'}``).
      See :doc:`trollimage:colormap` for the full list of available colormaps.
  
      **From an auxiliary variable**
  
      If the colormap is defined in the same dataset as the data to which the
      colormap shall be applied, this can be indicated with
      ``{'dataset': 'palette_variable'}``, where ``'palette_variable'`` is the
      name of the variable containing the palette.  This variable must be an
      auxiliary variable to the dataset to which the colours are applied.  When
      using this, it is important that one should **not** set ``min_value`` and
      ``max_value`` as those will be taken from the ``valid_range`` attribute
      on the dataset and if those differ from ``min_value`` and ``max_value``,
      the resulting colors will not match the ones in the palette.
  
      **Color Scale**
  
      By default colors are expected to be in a 0-255 range. This
      can be overridden by specifying ``color_scale`` in the provided colormap
      information. A common alternative to 255 is ``1`` to specify floating
      point numbers between 0 and 1. The resulting Colormap uses the normalized
      color values (0-1).
  
      **Set Range**
  
      By default the control points or values of the Colormap are between 0 and
      1. This means that data values being mapped to a color must also be
      between 0 and 1. When this is not the case, the expected input range of
      the data can be used to configure the Colormap and change the control point
      values. To do this specify the input data range with ``min_value`` and
      ``max_value``. See :meth:`trollimage.colormap.Colormap.set_range` for more
      information.
  
      """
      fname = palette.get("filename", None)
      colors = palette.get("colors", None)
      dataset = palette.get("dataset", None)
      # are colors between 0-255 or 0-1
      color_scale = palette.get("color_scale", 255)
      if fname:
          if not os.path.exists(fname):
              fname = get_config_path(fname)
          cmap = Colormap.from_file(
              fname, palette.get("colormap_mode", None), color_scale
          )
      elif isinstance(colors, (tuple, list)):
          cmap = Colormap.from_sequence_of_colors(
              colors, palette.get("values", None), color_scale
          )
      elif isinstance(colors, str):
          cmap = Colormap.from_name(colors)
      elif isinstance(dataset, str):
          cmap = _create_colormap_from_dataset(
              img, dataset, color_scale
          )
      else:
          raise ValueError(
              "Unknown colormap format: {}".format(palette)
          )
  
      if palette.get("reverse", False):
          cmap.reverse()
      if "min_value" in palette and "max_value" in palette:
          cmap.set_range(palette["min_value"], palette["max_value"])
      elif "min_value" in palette or "max_value" in palette:
          raise ValueError(
              "Both 'min_value' and 'max_value' must be specified (or neither)"
          )
  
      return cmap
  
imports: import logging
  import os
  from collections import namedtuple
  from functools import wraps
  from numbers import Number
  from typing import Optional
  import dask
  import dask.array
  import numpy
  import xarray
  from trollimage.colormap import Colormap
  from trollimage.xrimage import XRImage
  from satpy._compat import ArrayLike
  from satpy._config import get_config_path
  from satpy.utils import find_in_ancillary
label_desc: Use image node_id 20 for calling a global function with example usage: create_colormap(palette, img) and returns: cmap