docs: def create_index(self, cls_or_collection,
                       params=None, fields=None, ephemeral=False, unique=False):
          """Create new index on the given collection/class with given parameters.
  
          :param cls_or_collection:
              The name of the collection or the class for which to create an
              index
          :param params: The parameters of the index
          :param ephemeral: Whether to create a persistent or an ephemeral index
          :param unique: Whether the indexed field(s) must be unique
  
          `params` expects either a dictionary of parameters or a string value.
          In the latter case, it will interpret the string as the name of the key
          for which an index is to be created.
  
          If `ephemeral = True`, the index will be created only in memory and
          will not be written to disk when :py:meth:`.commit` is called. This is
          useful for optimizing query performance.
  
          ..notice::
  
             By default, BlitzDB will create ephemeral indexes for all keys over
             which you perform queries, so after you've run a query on a given
             key for the first time, the second run will usually be much faster.
  
          **Specifying keys**
  
          Keys can be specified just like in MongoDB, using a dot ('.') to
          specify nested keys.
  
          .. code-block:: python
  
             actor = Actor({'name' : 'Charlie Chaplin',
              'foo' : {'value' : 'bar'}})
  
          If you want to create an index on `actor['foo']['value']` , you can
          just say
  
          .. code-block:: python
  
             backend.create_index(Actor,'foo.value')
  
          .. warning::
  
              Transcendental indexes (i.e. indexes transcending the boundaries of
              referenced objects) are currently not supported by Blitz, which
              means you can't create an index on an attribute value of a document
              that is embedded in another document.
  
          """
          if params:
              return self.create_indexes(cls_or_collection, [params],
                                         ephemeral=ephemeral, unique=unique)
          elif fields:
              params = []
              if len(fields.items()) > 1:
                  raise ValueError("File backend currently does not support multi-key indexes, sorry :/")
              return self.create_indexes(cls_or_collection, [{'key': list(fields.keys())[0]}],
                                         ephemeral=ephemeral, unique=unique)
          else:
              raise AttributeError('You must either specify params or fields!')