#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include "pycore_namespace.h" // _PyNamespace_New()

typedef struct {

PyTime_t initialized;

PyObject *error;

PyObject *int_const;

PyObject *str_const;

} module_state;

static struct {

int initialized_count;

module_state module;

} global_state = {

#define NOT_INITIALIZED -1

.initialized_count = NOT_INITIALIZED,

};

static void clear_state(module_state *state);

static void

clear_global_state(void)

{

clear_state(&global_state.module);

global_state.initialized_count = NOT_INITIALIZED;

}

static inline module_state *

get_module_state(PyObject *module)

{

PyModuleDef *def = PyModule_GetDef(module);

assert(def);

if (def->m_size == -1) {

return &global_state.module;

}

else if (def->m_size == 0) {

return NULL;

}

else {

module_state *state = (module_state*)PyModule_GetState(module);

assert(state == PyModule_GetState_DuringGC(module));

assert(state != NULL);

return state;

}

}

static void

clear_state(module_state *state)

{

state->initialized = 0;

Py_CLEAR(state->error);

Py_CLEAR(state->int_const);

Py_CLEAR(state->str_const);

}

static int

_set_initialized(PyTime_t *initialized)

{

/* We go strictly monotonic to ensure each time is unique. */

PyTime_t prev;

if (PyTime_Monotonic(&prev) != 0) {

return -1;

}

/* We do a busy sleep since the interval should be super short. */

PyTime_t t;

do {

if (PyTime_Monotonic(&t) != 0) {

return -1;

}

} while (t == prev);

*initialized = t;

return 0;

}

static int

init_state(module_state *state)

{

assert(state->initialized == 0 &&

state->error == NULL &&

state->int_const == NULL &&

state->str_const == NULL);

if (_set_initialized(&state->initialized) != 0) {

goto error;

}

assert(state->initialized > 0);

/* Add an exception type */

state->error = PyErr_NewException("_testsinglephase.error", NULL, NULL);

if (state->error == NULL) {

goto error;

}

state->int_const = PyLong_FromLong(1969);

if (state->int_const == NULL) {

goto error;

}

state->str_const = PyUnicode_FromString("something different");

if (state->str_const == NULL) {

goto error;

}

return 0;

error:

clear_state(state);

return -1;

}

static int

init_module(PyObject *module, module_state *state)

{

if (PyModule_AddObjectRef(module, "error", state->error) != 0) {

return -1;

}

if (PyModule_AddObjectRef(module, "int_const", state->int_const) != 0) {

return -1;

}

if (PyModule_AddObjectRef(module, "str_const", state->str_const) != 0) {

return -1;

}

double d = PyTime_AsSecondsDouble(state->initialized);

if (PyModule_Add(module, "_module_initialized", PyFloat_FromDouble(d)) < 0) {

return -1;

}

return 0;

}

PyDoc_STRVAR(common_state_initialized_doc,

Return the seconds-since-epoch when the module state was initialized.");

static PyObject *

common_state_initialized(PyObject *self, PyObject *Py_UNUSED(ignored))

{

module_state *state = get_module_state(self);

if (state == NULL) {

Py_RETURN_NONE;

}

double d = PyTime_AsSecondsDouble(state->initialized);

return PyFloat_FromDouble(d);

}

#define STATE_INITIALIZED_METHODDEF \

{"state_initialized", common_state_initialized, METH_NOARGS, \

common_state_initialized_doc}

PyDoc_STRVAR(common_look_up_self_doc,

Return the module associated with this module's def.m_base.m_index.");

static PyObject *

common_look_up_self(PyObject *self, PyObject *Py_UNUSED(ignored))

{

PyModuleDef *def = PyModule_GetDef(self);

if (def == NULL) {

return NULL;

}

return Py_NewRef(

PyState_FindModule(def));

}

#define LOOK_UP_SELF_METHODDEF \

{"look_up_self", common_look_up_self, METH_NOARGS, common_look_up_self_doc}

PyDoc_STRVAR(common_sum_doc,

Return the sum of i and j.");

static PyObject *

common_sum(PyObject *self, PyObject *args)

{

long i, j;

long res;

if (!PyArg_ParseTuple(args, "ll:sum", &i, &j))

return NULL;

res = i + j;

return PyLong_FromLong(res);

}

#define SUM_METHODDEF \

{"sum", common_sum, METH_VARARGS, common_sum_doc}

PyDoc_STRVAR(basic_initialized_count_doc,

Return how many times the module has been initialized.");

static PyObject *

basic_initialized_count(PyObject *self, PyObject *Py_UNUSED(ignored))

{

assert(PyModule_GetDef(self)->m_size == -1);

return PyLong_FromLong(global_state.initialized_count);

}

#define INITIALIZED_COUNT_METHODDEF \

{"initialized_count", basic_initialized_count, METH_NOARGS, \

basic_initialized_count_doc}

PyDoc_STRVAR(basic__clear_globals_doc,

Free all global state and set it to uninitialized.");

static PyObject *

basic__clear_globals(PyObject *self, PyObject *Py_UNUSED(ignored))

{

assert(PyModule_GetDef(self)->m_size == -1);

clear_global_state();

Py_RETURN_NONE;

}

#define _CLEAR_GLOBALS_METHODDEF \

{"_clear_globals", basic__clear_globals, METH_NOARGS, \

basic__clear_globals_doc}

PyDoc_STRVAR(basic__clear_module_state_doc, "_clear_module_state()\n\

Free the module state and set it to uninitialized.");

static PyObject *

basic__clear_module_state(PyObject *self, PyObject *Py_UNUSED(ignored))

{

module_state *state = get_module_state(self);

if (state != NULL) {

clear_state(state);

}

Py_RETURN_NONE;

}

#define _CLEAR_MODULE_STATE_METHODDEF \

{"_clear_module_state", basic__clear_module_state, METH_NOARGS, \

basic__clear_module_state_doc}

static PyMethodDef TestMethods_Basic[] = {

LOOK_UP_SELF_METHODDEF,

SUM_METHODDEF,

STATE_INITIALIZED_METHODDEF,

INITIALIZED_COUNT_METHODDEF,

_CLEAR_GLOBALS_METHODDEF,

{NULL, NULL} /* sentinel */

};

static struct PyModuleDef _testsinglephase_basic = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase",

.m_doc = PyDoc_STR("Test module _testsinglephase"),

.m_size = -1, // no module state

.m_methods = TestMethods_Basic,

};

static PyObject *

init__testsinglephase_basic(PyModuleDef *def)

{

if (global_state.initialized_count == -1) {

global_state.initialized_count = 0;

}

PyObject *module = PyModule_Create(def);

if (module == NULL) {

return NULL;

}

#ifdef Py_GIL_DISABLED

PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);

module_state *state = &global_state.module;

// It may have been set by a previous run or under a different name.

clear_state(state);

if (init_state(state) < 0) {

Py_CLEAR(module);

return NULL;

}

if (init_module(module, state) < 0) {

Py_CLEAR(module);

goto finally;

}

global_state.initialized_count++;

finally:

return module;

}

PyInit__testsinglephase(void)

{

return init__testsinglephase_basic(&_testsinglephase_basic);

}

PyInit__testsinglephase_basic_wrapper(void)

{

return PyInit__testsinglephase();

}

PyInit__testsinglephase_basic_copy(void)

{

static struct PyModuleDef def = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_basic_copy",

.m_doc = PyDoc_STR("Test module _testsinglephase_basic_copy"),

.m_size = -1, // no module state

.m_methods = TestMethods_Basic,

};

return init__testsinglephase_basic(&def);

}

static PyMethodDef TestMethods_Reinit[] = {

LOOK_UP_SELF_METHODDEF,

SUM_METHODDEF,

STATE_INITIALIZED_METHODDEF,

{NULL, NULL} /* sentinel */

};

static struct PyModuleDef _testsinglephase_with_reinit = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_with_reinit",

.m_doc = PyDoc_STR("Test module _testsinglephase_with_reinit"),

.m_size = 0,

.m_methods = TestMethods_Reinit,

};

PyInit__testsinglephase_with_reinit(void)

{

/* We purposefully do not try PyState_FindModule() first here

PyObject *module = PyModule_Create(&_testsinglephase_with_reinit);

if (module == NULL) {

return NULL;

}

#ifdef Py_GIL_DISABLED

PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);

assert(get_module_state(module) == NULL);

module_state state = {0};

if (init_state(&state) < 0) {

Py_CLEAR(module);

return NULL;

}

if (init_module(module, &state) < 0) {

Py_CLEAR(module);

goto finally;

}

finally:

/* We only needed the module state for setting the module attrs. */

clear_state(&state);

return module;

}

static PyMethodDef TestMethods_WithState[] = {

LOOK_UP_SELF_METHODDEF,

SUM_METHODDEF,

STATE_INITIALIZED_METHODDEF,

_CLEAR_MODULE_STATE_METHODDEF,

{NULL, NULL} /* sentinel */

};

static struct PyModuleDef _testsinglephase_with_state = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_with_state",

.m_doc = PyDoc_STR("Test module _testsinglephase_with_state"),

.m_size = sizeof(module_state),

.m_methods = TestMethods_WithState,

};

PyInit__testsinglephase_with_state(void)

{

/* We purposefully do not try PyState_FindModule() first here

PyObject *module = PyModule_Create(&_testsinglephase_with_state);

if (module == NULL) {

return NULL;

}

#ifdef Py_GIL_DISABLED

PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);

module_state *state = get_module_state(module);

assert(state != NULL);

if (init_state(state) < 0) {

Py_CLEAR(module);

return NULL;

}

if (init_module(module, state) < 0) {

clear_state(state);

Py_CLEAR(module);

goto finally;

}

finally:

return module;

}

static struct PyModuleDef _testsinglephase_check_cache_first = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_check_cache_first",

.m_doc = PyDoc_STR("Test module _testsinglephase_check_cache_first"),

.m_size = -1, // no module state

};

PyInit__testsinglephase_check_cache_first(void)

{

assert(_testsinglephase_check_cache_first.m_base.m_index == 0);

PyObject *mod = PyState_FindModule(&_testsinglephase_check_cache_first);

if (mod != NULL) {

return Py_NewRef(mod);

}

return PyModule_Create(&_testsinglephase_check_cache_first);

}

static struct PyModuleDef _testsinglephase_with_reinit_check_cache_first = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_with_reinit_check_cache_first",

.m_doc = PyDoc_STR("Test module _testsinglephase_with_reinit_check_cache_first"),

.m_size = 0, // no module state

};

PyInit__testsinglephase_with_reinit_check_cache_first(void)

{

assert(_testsinglephase_with_reinit_check_cache_first.m_base.m_index == 0);

PyObject *mod = PyState_FindModule(&_testsinglephase_with_reinit_check_cache_first);

if (mod != NULL) {

return Py_NewRef(mod);

}

return PyModule_Create(&_testsinglephase_with_reinit_check_cache_first);

}

static struct PyModuleDef _testsinglephase_with_state_check_cache_first = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_with_state_check_cache_first",

.m_doc = PyDoc_STR("Test module _testsinglephase_with_state_check_cache_first"),

.m_size = 42, // not used

};

PyInit__testsinglephase_with_state_check_cache_first(void)

{

assert(_testsinglephase_with_state_check_cache_first.m_base.m_index == 0);

PyObject *mod = PyState_FindModule(&_testsinglephase_with_state_check_cache_first);

if (mod != NULL) {

return Py_NewRef(mod);

}

return PyModule_Create(&_testsinglephase_with_state_check_cache_first);

}

static PyObject *static_module_circular;

static PyObject *

circularmod_clear_static_var(PyObject *self, PyObject *arg)

{

PyObject *result = static_module_circular;

static_module_circular = NULL;

return result;

}

static struct PyModuleDef _testsinglephase_circular = {

PyModuleDef_HEAD_INIT,

.m_name = "_testsinglephase_circular",

.m_doc = PyDoc_STR("Test module _testsinglephase_circular"),

.m_methods = (PyMethodDef[]) {

{"clear_static_var", circularmod_clear_static_var, METH_NOARGS,

"Clear the static variable and return its previous value."},

{NULL, NULL} /* sentinel */

}

};

PyInit__testsinglephase_circular(void)

{

if (!static_module_circular) {

static_module_circular = PyModule_Create(&_testsinglephase_circular);

if (!static_module_circular) {

return NULL;

}

}

static const char helper_mod_name[] = (

"test.test_import.data.circular_imports.singlephase");

PyObject *helper_mod = PyImport_ImportModule(helper_mod_name);

Py_XDECREF(helper_mod);

if (!helper_mod) {

return NULL;

}

if(PyModule_AddStringConstant(static_module_circular,

"helper_mod_name",

helper_mod_name) < 0) {

return NULL;

}

return Py_NewRef(static_module_circular);

}

PyInit__testsinglephase_raise_exception(void)

{

PyErr_SetString(PyExc_RuntimeError, "evil");

return NULL;

}