'Transactionally retrieve or create an instance of Model class.
This acts much like the Python dictionary setdefault() method, where we
first try to retrieve a Model instance with the given key name and parent.
If it\'s not present, then we create a new instance (using the *kwds
supplied) and insert that with the supplied key name.
Subsequent calls to this method with the same key_name and parent will
always yield the same entity (though not the same actual object instance),
regardless of the *kwds supplied. If the specified entity has somehow
been deleted separately, then the next call will create a new entity and
return it.
If the \'parent\' keyword argument is supplied, it must be a Model instance.
It will be used as the parent of the new instance of this Model class if
one is created.
This method is especially useful for having just one unique entity for
a specific identifier. Insertion/retrieval is done transactionally, which
guarantees uniqueness.
Example usage:
class WikiTopic(db.Model):
creation_date = db.DatetimeProperty(auto_now_add=True)
body = db.TextProperty(required=True)
# The first time through we\'ll create the new topic.
wiki_word = \'CommonIdioms\'
topic = WikiTopic.get_or_insert(wiki_word,
body=\'This topic is totally new!\')
assert topic.key().name() == \'CommonIdioms\'
assert topic.body == \'This topic is totally new!\'
# The second time through will just retrieve the entity.
overwrite_topic = WikiTopic.get_or_insert(wiki_word,
body=\'A totally different message!\')
assert topic.key().name() == \'CommonIdioms\'
assert topic.body == \'This topic is totally new!\'
Args:
key_name: Key name to retrieve or create.
**kwds: Keyword arguments to pass to the constructor of the model class
if an instance for the specified key name does not already exist. If
an instance with the supplied key_name and parent already exists, the
rest of these arguments will be discarded.
Returns:
Existing instance of Model class with the specified key_name and parent
or a new one that has just been created.
Raises:
TransactionFailedError if the specified Model instance could not be
retrieved or created transactionally (due to high contention, etc).'

@classmethod
def get_or_insert(cls, key_name, **kwds):

    def txn():
        entity = cls.get_by_key_name(key_name, parent=kwds.get('parent'))
        if (entity is None):
            entity = cls(key_name=key_name, **kwds)
            entity.put()
        return entity
    return run_in_transaction(txn)
