How to auto-update update time in MongoEngine?

Setting the defaults to be utcnow() with the parentheses causes Python to execute the utcnow function when the class is created, not when a new object using that class is created. Instead, you should set the default to be the function without the (). That will pass the function as an object itself instead of calling it right away, and when a new object is created from this class, the function will execute.

Also, the Python docs recommend using datetime.now over utcnow. Going with that, your example should look like this:

import datetime

class Example(mongoengine.Document):
    created_at = db.DateTimeField(required=True, default=datetime.datetime.now)
    updated_at = db.DateTimeField(required=True, default=datetime.datetime.now)

As for updating the updated_at attribute whenever you call save(), you can create a wrapper function for save() that will set updated_at to datetime.now(), then save. Then, instead of calling save(), call your wrapper function whenever you want to save.

A wrapper function is a function that does a little preprocessing and then calls another function (see wikipedia: https://en.wikipedia.org/wiki/Wrapper_function).

For example, you write a function like this:

def my_save(object):
    object.updated_at = datetime.datetime.now()
    return object.save()

And then whenever you want to save an object, you call my_save() instead of object.save().

Another option is to use inheritance (assuming you would like to have this two fields defined in more then a single model): create a base class with created/updated timestamp fields, override save method and inherite your document class from this base class:

import datetime

class TimestampedDocument(Document):

    meta = {'allow_inheritance': True, 'abstract': True}

    created_at = DateTimeField(required=True, default=datetime.datetime.now)
    updated_at = DateTimeField(required=True, default=datetime.datetime.now)

    def save(
        self,
        force_insert=False,
        validate=True,
        clean=True,
        write_concern=None,
        cascade=None,
        cascade_kwargs=None,
        _refs=None,
        save_condition=None,
        signal_kwargs=None,
        **kwargs,
    ):
        self.updated = datetime.datetime.now()
        super().save(
            force_insert, validate, clean, write_concern, cascade, cascade_kwargs, _refs, save_condition,
            signal_kwargs, **kwargs
        )

...

class YourDocument(TimestampedDocument):
    meta = {'collection': 'YourDocument'}

In this case created_at is set one's when document is created and updated_at updates each time you modify the doc.

The method that worked for me was first creating a document using datetime.utc, as MongoDB converted the timedate information within the DB to the appropriate timezone values upon retrieval to my client app.

from mongoengine import Document, fields
from datetime import datetime
    
class Example(Document):
    created_at = fields.DateTimeField(required=True, default=datetime.utcnow)
    updated_at = fields.DateTimeField(required=True, default=datetime.utcnow)

Whenever there is a request to update a specific instance of a document, the "updated_at" key is indexed from the data, and is given a new value, that being the current datetime.utcnow(). The specific document is then found from the database via the primary key. After this, just save the changes. I also added some additional lines, when using serializers.

from rest_framework.response import Response
from .models import Example
from .serializers import ExampleSerializer
from datetime import datetime

def updateDocument(request, pk): 
    data = request.data
    data["updated_at"] = datetime.utcnow()
    document = Example.objects.get(id=pk)
    serializer = ExampleSerializer(instance=document, data=data)

    if serializer.is_valid():
        serializer.save()

    return Response(serializer.data)