code: def get(self, key, missing=None, deferred=None, transaction=None, eventual=False):
          
          entities = self.get_multi(
              keys=[key],
              missing=missing,
              deferred=deferred,
              transaction=transaction,
              eventual=eventual,
          )
          if entities:
              return entities[0]
docs: Retrieve an entity from a single key (if it exists).
  
          .. note::
  
             This is just a thin wrapper over :meth:`get_multi`.
             The backend API does not make a distinction between a single key or
             multiple keys in a lookup request.
  
          :type key: :class:`google.cloud.datastore.key.Key`
          :param key: The key to be retrieved from the datastore.
  
          :type missing: list
          :param missing: (Optional) If a list is passed, the key-only entities
                          returned by the backend as "missing" will be copied
                          into it.
  
          :type deferred: list
          :param deferred: (Optional) If a list is passed, the keys returned
                           by the backend as "deferred" will be copied into it.
  
          :type transaction:
              :class:`~google.cloud.datastore.transaction.Transaction`
          :param transaction: (Optional) Transaction to use for read consistency.
                              If not passed, uses current transaction, if set.
  
          :type eventual: bool
          :param eventual: (Optional) Defaults to strongly consistent (False).
                           Setting True will use eventual consistency, but cannot
                           be used inside a transaction or will raise ValueError.
  
          :rtype: :class:`google.cloud.datastore.entity.Entity` or ``NoneType``
          :returns: The requested entity if it exists.
  
          :raises: :class:`ValueError` if eventual is True and in a transaction.