Closing a long-lived client/session with weakref.finalize

[flaeppe]

Hi,

I'm curious if it'd be reasonable to set up an atexit finalizer (weakref.finalize) on Client.close for any long-lived client (i.e. not using it as a contextmanager). I've seen that Client.__del__ is calling .close, but in general I'm wondering if I would run in to any obvious troubles by using weakref.finalize on Client.close? Or if it could just be superfluous and I shouldn't bother?

Thanks.

[lovelydinosaur]

Could you explain the motivation more here, or given an example and show what that might be something you'd want to do?

(My short version reply, without understanding the issue better, is that you probably just don't need to do this.)

[flaeppe]

Sure, I've tried to mock up an example below of what I'm trying to achieve.

Basically I'm trying to set up an interface(call_1 and call_2 below) which communicates externally, with an httpx.Client that I'd like to be reusable for any future requests via this interface. So, if a client has been initiated via a call through this interface, any subsequent calls could use the same client.

# external_api.py

_session = contextvars.ContextVar("my_client")


class MyClient(httpx.Client):
    def __init__(self, *args, **kwargs):
        kwargs.setdefault("base_url", "http://some.where/")
        super().__init__(*args, **kwargs)
        weakref.finalize(self, self.close)

    @classmethod
    def get_session(cls):
        if (session := _session.get(None)) is not None:
            return session
        _session.set(cls())
        return _session.get()


def call_1():
    session = MyClient.get_session()
    response = session.get("call/1")
    response.raise_for_status()
    return response.json()


def call_2():
    session = MyClient.get_session()
    response = session.get("call/2")
    response.raise_for_status()
    return response.json()

Due to the ContextVar here, and that any client instance could be kept alive for as long as my program is running, the weakref.finalize(self, self.close) came to mind. This raised some questions regarding it being a necessity, i.e. garbage collection didn't happen for whatever reason. While having an atexit finalizer would then still help us call .close.

Although, since __del__ is already calling .close for cases when it's invoked, then the atexit finalizer would attempt the same thing. But from what I can currently tell from just browsing the .close-implementation, it looks idempotent(?) and an atexit finalizer attempting calling it again, should be OK.

I should mention I haven't tested an implementation with weakref.finalize (yet).