PTAL, @vstinner

If PyInit__datetime() fails, I suppose that the next call may override global state without clearing the previous strong refererence: reference leak. I don't think that we should bother since this state is going to become more dynamic and set differently, no?

Well, it is easy to already now add the machinery needed to clear the state (future m_clear function). It's easy to add such a function now, and call it in the PyInit__datetime() error path. It will be an improvement over status quo where global state is overwritten anyway.

Note that parts of the state actually is cleared if the module exec function fails.

Perhaps we should start with a PR that cleans up _datetime init code?

Thanks for the review, Victor!

There are lots of paths we can take for the follow-up PRs.

Alt 1, continue adding to static state:

• Convert static types to heap types; add them to static state
• Convert static state to module state (will break encapsulated C API)
• Deprecate encapsulated C API and introduce a new one based on module state

Alt 2, try to save the encapsulated C API by moving static state to the interpreter

• Move existing static state to the interpreter
• Convert static types to heap types; add them to the interpreter owned state struct

What do you think, Victor?

Convert static types to heap types; add them to static state

Sounds like a good step.

Move existing static state to the interpreter

I would prefer to consider that after converting types to heap types.

IMO the C API like PyDateTime_Check() will prevent to make this state per module. Instead, you can consider splitting this state in two states:

• One state per interpreter: anything involing types and instances of these types
• One state per module instance: constants like "microseconds per second"

You simply cannot have more than one instance of the same type beause of PyDateTime_Check().

PyDateTime_Check() will be per-interpreter. I had the exact same problem with PyAST_Check():

int PyAST_Check(PyObject* obj)
{
    struct ast_state *state = get_ast_state();
    if (state == NULL) {
        return -1;
    }
    return PyObject_IsInstance(obj, state->AST_type);
}

    if (state == NULL) {
        return -1;
    }

By the way, the error case could be avoided by running the initialization at Python startup.

Hi Erlend, would it be possible for you to support this for Python 3.12?

Hi Erlend, would it be possible for you to support this for Python 3.12?

No; that would be a breaking change.