How should I implement caching correctly?

[wildsheepz]

After looking at the docs, it seems I'm supposed to create a subclass of MethodAnnotation. But I can't figure out how to intercept the mechanism that makes the request to return the cached result instead.
This is a snippet of my code so far:

class CachingRequestTemplate(uplink.clients.io.RequestTemplate):
    def __init__(self, ttl):
        super().__init__()
        self.ttl = ttl
        self.cache = {}
        self.cache_ttl = {}

    def before_request(self, request):
        if request in self.cache and time.time() < self.cache_ttl.get(request, 0):
          raise uplink.exceptions.CachedResponse(self.cache[request])     

    def after_response(self, request, response):
        if 200 <= response.status_code < 300:
            _ = response.content
            self.cache[request] = response
            self.cache_ttl[request] = time.time() + self.ttl
        return response


class cache(uplink.decorators.MethodAnnotation):
    def __init__(self, hours=0, minutes=0, seconds=0):
        self.caching_request_template = CachingRequestTemplate(self.hours * 3600 + minutes * 60 + seconds)

    def __call__(self, class_or_builder, **kwargs):
        return super().__call__(class_or_builder, **kwargs)

    def modify_request(self, request_builder: uplink.helpers.RequestBuilder):
        request_builder.add_request_template(template=self.caching_request_template)


class ExampleUplinkClient(uplink.Consumer):

    @cache(hours=1)
    @uplink.get("some_url_endpoint")
    def get_some_endpoint(self):
        pass