context.c

#include"Python.h"
#include"pycore_call.h"// _PyObject_VectorcallTstate()
#include"pycore_context.h"
#include"pycore_gc.h"// _PyObject_GC_MAY_BE_TRACKED()
#include"pycore_hamt.h"
#include"pycore_initconfig.h"// _PyStatus_OK()
#include"pycore_object.h"
#include"pycore_pyerrors.h"
#include"pycore_pystate.h"// _PyThreadState_GET()



#include"clinic/context.c.h"
/*[clinic input]
module _contextvars
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a0955718c8b8cea6]*/


#defineENSURE_Context(o, err_ret) \
 if (!PyContext_CheckExact(o)) { \
 PyErr_SetString(PyExc_TypeError, \
 "an instance of Context was expected"); \
 return err_ret; \
 }

#defineENSURE_ContextVar(o, err_ret) \
 if (!PyContextVar_CheckExact(o)) { \
 PyErr_SetString(PyExc_TypeError, \
 "an instance of ContextVar was expected"); \
 return err_ret; \
 }

#defineENSURE_ContextToken(o, err_ret) \
 if (!PyContextToken_CheckExact(o)) { \
 PyErr_SetString(PyExc_TypeError, \
 "an instance of Token was expected"); \
 return err_ret; \
 }


/////////////////////////// Context API


staticPyContext*
context_new_empty(void);

staticPyContext*
context_new_from_vars(PyHamtObject*vars);

staticinlinePyContext*
context_get(void);

staticPyContextToken*
token_new(PyContext*ctx, PyContextVar*var, PyObject*val);

staticPyContextVar*
contextvar_new(PyObject*name, PyObject*def);

staticint
contextvar_set(PyContextVar*var, PyObject*val);

staticint
contextvar_del(PyContextVar*var);


#ifdefWITH_FREELISTS
staticstruct_Py_context_freelist*
get_context_freelist(void)
{
struct_Py_object_freelists*freelists=_Py_object_freelists_GET();
return&freelists->contexts;
}
#endif


PyObject*
_PyContext_NewHamtForTests(void)
{
return (PyObject*)_PyHamt_New();
}


PyObject*
PyContext_New(void)
{
return (PyObject*)context_new_empty();
}


PyObject*
PyContext_Copy(PyObject*octx)
{
ENSURE_Context(octx, NULL)
PyContext*ctx= (PyContext*)octx;
return (PyObject*)context_new_from_vars(ctx->ctx_vars);
}


PyObject*
PyContext_CopyCurrent(void)
{
PyContext*ctx=context_get();
if (ctx==NULL) {
returnNULL;
 }

return (PyObject*)context_new_from_vars(ctx->ctx_vars);
}


staticint
_PyContext_Enter(PyThreadState*ts, PyObject*octx)
{
ENSURE_Context(octx, -1)
PyContext*ctx= (PyContext*)octx;

if (ctx->ctx_entered) {
_PyErr_Format(ts, PyExc_RuntimeError,
"cannot enter context: %R is already entered", ctx);
return-1;
 }

ctx->ctx_prev= (PyContext*)ts->context; /* borrow */
ctx->ctx_entered=1;

ts->context=Py_NewRef(ctx);
ts->context_ver++;

return0;
}


int
PyContext_Enter(PyObject*octx)
{
PyThreadState*ts=_PyThreadState_GET();
assert(ts!=NULL);
return_PyContext_Enter(ts, octx);
}


staticint
_PyContext_Exit(PyThreadState*ts, PyObject*octx)
{
ENSURE_Context(octx, -1)
PyContext*ctx= (PyContext*)octx;

if (!ctx->ctx_entered) {
PyErr_Format(PyExc_RuntimeError,
"cannot exit context: %R has not been entered", ctx);
return-1;
 }

if (ts->context!= (PyObject*)ctx) {
/* Can only happen if someone misuses the C API */
PyErr_SetString(PyExc_RuntimeError,
"cannot exit context: thread state references "
"a different context object");
return-1;
 }

Py_SETREF(ts->context, (PyObject*)ctx->ctx_prev);
ts->context_ver++;

ctx->ctx_prev=NULL;
ctx->ctx_entered=0;

return0;
}

int
PyContext_Exit(PyObject*octx)
{
PyThreadState*ts=_PyThreadState_GET();
assert(ts!=NULL);
return_PyContext_Exit(ts, octx);
}


PyObject*
PyContextVar_New(constchar*name, PyObject*def)
{
PyObject*pyname=PyUnicode_FromString(name);
if (pyname==NULL) {
returnNULL;
 }
PyContextVar*var=contextvar_new(pyname, def);
Py_DECREF(pyname);
return (PyObject*)var;
}


int
PyContextVar_Get(PyObject*ovar, PyObject*def, PyObject**val)
{
ENSURE_ContextVar(ovar, -1)
PyContextVar*var= (PyContextVar*)ovar;

PyThreadState*ts=_PyThreadState_GET();
assert(ts!=NULL);
if (ts->context==NULL) {
 goto not_found;
 }

#ifndefPy_GIL_DISABLED
if (var->var_cached!=NULL&&
var->var_cached_tsid==ts->id&&
var->var_cached_tsver==ts->context_ver)
 {
*val=var->var_cached;
 goto found;
 }
#endif

assert(PyContext_CheckExact(ts->context));
PyHamtObject*vars= ((PyContext*)ts->context)->ctx_vars;

PyObject*found=NULL;
intres=_PyHamt_Find(vars, (PyObject*)var, &found);
if (res<0) {
 goto error;
 }
if (res==1) {
assert(found!=NULL);
#ifndefPy_GIL_DISABLED
var->var_cached=found; /* borrow */
var->var_cached_tsid=ts->id;
var->var_cached_tsver=ts->context_ver;
#endif

*val=found;
 goto found;
 }

not_found:
if (def==NULL) {
if (var->var_default!=NULL) {
*val=var->var_default;
 goto found;
 }

*val=NULL;
 goto found;
 }
else {
*val=def;
 goto found;
 }

found:
Py_XINCREF(*val);
return0;

error:
*val=NULL;
return-1;
}


PyObject*
PyContextVar_Set(PyObject*ovar, PyObject*val)
{
ENSURE_ContextVar(ovar, NULL)
PyContextVar*var= (PyContextVar*)ovar;

if (!PyContextVar_CheckExact(var)) {
PyErr_SetString(
PyExc_TypeError, "an instance of ContextVar was expected");
returnNULL;
 }

PyContext*ctx=context_get();
if (ctx==NULL) {
returnNULL;
 }

PyObject*old_val=NULL;
intfound=_PyHamt_Find(ctx->ctx_vars, (PyObject*)var, &old_val);
if (found<0) {
returnNULL;
 }

Py_XINCREF(old_val);
PyContextToken*tok=token_new(ctx, var, old_val);
Py_XDECREF(old_val);

if (contextvar_set(var, val)) {
Py_DECREF(tok);
returnNULL;
 }

return (PyObject*)tok;
}


int
PyContextVar_Reset(PyObject*ovar, PyObject*otok)
{
ENSURE_ContextVar(ovar, -1)
ENSURE_ContextToken(otok, -1)
PyContextVar*var= (PyContextVar*)ovar;
PyContextToken*tok= (PyContextToken*)otok;

if (tok->tok_used) {
PyErr_Format(PyExc_RuntimeError,
"%R has already been used once", tok);
return-1;
 }

if (var!=tok->tok_var) {
PyErr_Format(PyExc_ValueError,
"%R was created by a different ContextVar", tok);
return-1;
 }

PyContext*ctx=context_get();
if (ctx!=tok->tok_ctx) {
PyErr_Format(PyExc_ValueError,
"%R was created in a different Context", tok);
return-1;
 }

tok->tok_used=1;

if (tok->tok_oldval==NULL) {
returncontextvar_del(var);
 }
else {
returncontextvar_set(var, tok->tok_oldval);
 }
}


/////////////////////////// PyContext

/*[clinic input]
class _contextvars.Context "PyContext *" "&PyContext_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=bdf87f8e0cb580e8]*/


staticinlinePyContext*
_context_alloc(void)
{
PyContext*ctx;
#ifdefWITH_FREELISTS
struct_Py_context_freelist*context_freelist=get_context_freelist();
if (context_freelist->numfree>0) {
context_freelist->numfree--;
ctx=context_freelist->items;
context_freelist->items= (PyContext*)ctx->ctx_weakreflist;
OBJECT_STAT_INC(from_freelist);
ctx->ctx_weakreflist=NULL;
_Py_NewReference((PyObject*)ctx);
 }
else
#endif
 {
ctx=PyObject_GC_New(PyContext, &PyContext_Type);
if (ctx==NULL) {
returnNULL;
 }
 }

ctx->ctx_vars=NULL;
ctx->ctx_prev=NULL;
ctx->ctx_entered=0;
ctx->ctx_weakreflist=NULL;

returnctx;
}


staticPyContext*
context_new_empty(void)
{
PyContext*ctx=_context_alloc();
if (ctx==NULL) {
returnNULL;
 }

ctx->ctx_vars=_PyHamt_New();
if (ctx->ctx_vars==NULL) {
Py_DECREF(ctx);
returnNULL;
 }

_PyObject_GC_TRACK(ctx);
returnctx;
}


staticPyContext*
context_new_from_vars(PyHamtObject*vars)
{
PyContext*ctx=_context_alloc();
if (ctx==NULL) {
returnNULL;
 }

ctx->ctx_vars= (PyHamtObject*)Py_NewRef(vars);

_PyObject_GC_TRACK(ctx);
returnctx;
}


staticinlinePyContext*
context_get(void)
{
PyThreadState*ts=_PyThreadState_GET();
assert(ts!=NULL);
PyContext*current_ctx= (PyContext*)ts->context;
if (current_ctx==NULL) {
current_ctx=context_new_empty();
if (current_ctx==NULL) {
returnNULL;
 }
ts->context= (PyObject*)current_ctx;
 }
returncurrent_ctx;
}

staticint
context_check_key_type(PyObject*key)
{
if (!PyContextVar_CheckExact(key)) {
// abort();
PyErr_Format(PyExc_TypeError,
"a ContextVar key was expected, got %R", key);
return-1;
 }
return0;
}

staticPyObject*
context_tp_new(PyTypeObject*type, PyObject*args, PyObject*kwds)
{
if (PyTuple_Size(args) || (kwds!=NULL&&PyDict_Size(kwds))) {
PyErr_SetString(
PyExc_TypeError, "Context() does not accept any arguments");
returnNULL;
 }
returnPyContext_New();
}

staticint
context_tp_clear(PyContext*self)
{
Py_CLEAR(self->ctx_prev);
Py_CLEAR(self->ctx_vars);
return0;
}

staticint
context_tp_traverse(PyContext*self, visitprocvisit, void*arg)
{
Py_VISIT(self->ctx_prev);
Py_VISIT(self->ctx_vars);
return0;
}

staticvoid
context_tp_dealloc(PyContext*self)
{
_PyObject_GC_UNTRACK(self);

if (self->ctx_weakreflist!=NULL) {
PyObject_ClearWeakRefs((PyObject*)self);
 }
 (void)context_tp_clear(self);

#ifdefWITH_FREELISTS
struct_Py_context_freelist*context_freelist=get_context_freelist();
if (context_freelist->numfree >= 0&&context_freelist->numfree<PyContext_MAXFREELIST) {
context_freelist->numfree++;
self->ctx_weakreflist= (PyObject*)context_freelist->items;
context_freelist->items=self;
OBJECT_STAT_INC(to_freelist);
 }
else
#endif
 {
Py_TYPE(self)->tp_free(self);
 }
}

staticPyObject*
context_tp_iter(PyContext*self)
{
return_PyHamt_NewIterKeys(self->ctx_vars);
}

staticPyObject*
context_tp_richcompare(PyObject*v, PyObject*w, intop)
{
if (!PyContext_CheckExact(v) || !PyContext_CheckExact(w) ||
 (op!=Py_EQ&&op!=Py_NE))
 {
Py_RETURN_NOTIMPLEMENTED;
 }

intres=_PyHamt_Eq(
 ((PyContext*)v)->ctx_vars, ((PyContext*)w)->ctx_vars);
if (res<0) {
returnNULL;
 }

if (op==Py_NE) {
res= !res;
 }

if (res) {
Py_RETURN_TRUE;
 }
else {
Py_RETURN_FALSE;
 }
}

staticPy_ssize_t
context_tp_len(PyContext*self)
{
return_PyHamt_Len(self->ctx_vars);
}

staticPyObject*
context_tp_subscript(PyContext*self, PyObject*key)
{
if (context_check_key_type(key)) {
returnNULL;
 }
PyObject*val=NULL;
intfound=_PyHamt_Find(self->ctx_vars, key, &val);
if (found<0) {
returnNULL;
 }
if (found==0) {
PyErr_SetObject(PyExc_KeyError, key);
returnNULL;
 }
returnPy_NewRef(val);
}

staticint
context_tp_contains(PyContext*self, PyObject*key)
{
if (context_check_key_type(key)) {
return-1;
 }
PyObject*val=NULL;
return_PyHamt_Find(self->ctx_vars, key, &val);
}


/*[clinic input]
_contextvars.Context.get
 key: object
 default: object = None
 /

Return the value for `key` if `key` has the value in the context object.

If `key` does not exist, return `default`. If `default` is not given,
return None.
[clinic start generated code]*/

staticPyObject*
_contextvars_Context_get_impl(PyContext*self, PyObject*key,
PyObject*default_value)
/*[clinic end generated code: output=0c54aa7664268189 input=c8eeb81505023995]*/
{
if (context_check_key_type(key)) {
returnNULL;
 }

PyObject*val=NULL;
intfound=_PyHamt_Find(self->ctx_vars, key, &val);
if (found<0) {
returnNULL;
 }
if (found==0) {
returnPy_NewRef(default_value);
 }
returnPy_NewRef(val);
}


/*[clinic input]
_contextvars.Context.items

Return all variables and their values in the context object.

The result is returned as a list of 2-tuples (variable, value).
[clinic start generated code]*/

staticPyObject*
_contextvars_Context_items_impl(PyContext*self)
/*[clinic end generated code: output=fa1655c8a08502af input=00db64ae379f9f42]*/
{
return_PyHamt_NewIterItems(self->ctx_vars);
}


/*[clinic input]
_contextvars.Context.keys

Return a list of all variables in the context object.
[clinic start generated code]*/

staticPyObject*
_contextvars_Context_keys_impl(PyContext*self)
/*[clinic end generated code: output=177227c6b63ec0e2 input=114b53aebca3449c]*/
{
return_PyHamt_NewIterKeys(self->ctx_vars);
}


/*[clinic input]
_contextvars.Context.values

Return a list of all variables' values in the context object.
[clinic start generated code]*/

staticPyObject*
_contextvars_Context_values_impl(PyContext*self)
/*[clinic end generated code: output=d286dabfc8db6dde input=ce8075d04a6ea526]*/
{
return_PyHamt_NewIterValues(self->ctx_vars);
}


/*[clinic input]
_contextvars.Context.copy

Return a shallow copy of the context object.
[clinic start generated code]*/

staticPyObject*
_contextvars_Context_copy_impl(PyContext*self)
/*[clinic end generated code: output=30ba8896c4707a15 input=ebafdbdd9c72d592]*/
{
return (PyObject*)context_new_from_vars(self->ctx_vars);
}


staticPyObject*
context_run(PyContext*self, PyObject*const*args,
Py_ssize_tnargs, PyObject*kwnames)
{
PyThreadState*ts=_PyThreadState_GET();

if (nargs<1) {
_PyErr_SetString(ts, PyExc_TypeError,
"run() missing 1 required positional argument");
returnNULL;
 }

if (_PyContext_Enter(ts, (PyObject*)self)) {
returnNULL;
 }

PyObject*call_result=_PyObject_VectorcallTstate(
ts, args[0], args+1, nargs-1, kwnames);

if (_PyContext_Exit(ts, (PyObject*)self)) {
Py_XDECREF(call_result);
returnNULL;
 }

returncall_result;
}


staticPyMethodDefPyContext_methods[] = {
_CONTEXTVARS_CONTEXT_GET_METHODDEF
_CONTEXTVARS_CONTEXT_ITEMS_METHODDEF
_CONTEXTVARS_CONTEXT_KEYS_METHODDEF
_CONTEXTVARS_CONTEXT_VALUES_METHODDEF
_CONTEXTVARS_CONTEXT_COPY_METHODDEF
 {"run", _PyCFunction_CAST(context_run), METH_FASTCALL | METH_KEYWORDS, NULL},
 {NULL, NULL}
};

staticPySequenceMethodsPyContext_as_sequence= {
0, /* sq_length */
0, /* sq_concat */
0, /* sq_repeat */
0, /* sq_item */
0, /* sq_slice */
0, /* sq_ass_item */
0, /* sq_ass_slice */
 (objobjproc)context_tp_contains, /* sq_contains */
0, /* sq_inplace_concat */
0, /* sq_inplace_repeat */
};

staticPyMappingMethodsPyContext_as_mapping= {
 (lenfunc)context_tp_len, /* mp_length */
 (binaryfunc)context_tp_subscript, /* mp_subscript */
};

PyTypeObjectPyContext_Type= {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"_contextvars.Context",
sizeof(PyContext),
 .tp_methods=PyContext_methods,
 .tp_as_mapping=&PyContext_as_mapping,
 .tp_as_sequence=&PyContext_as_sequence,
 .tp_iter= (getiterfunc)context_tp_iter,
 .tp_dealloc= (destructor)context_tp_dealloc,
 .tp_getattro=PyObject_GenericGetAttr,
 .tp_flags=Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
 .tp_richcompare=context_tp_richcompare,
 .tp_traverse= (traverseproc)context_tp_traverse,
 .tp_clear= (inquiry)context_tp_clear,
 .tp_new=context_tp_new,
 .tp_weaklistoffset= offsetof(PyContext, ctx_weakreflist),
 .tp_hash=PyObject_HashNotImplemented,
};


/////////////////////////// ContextVar


staticint
contextvar_set(PyContextVar*var, PyObject*val)
{
#ifndefPy_GIL_DISABLED
var->var_cached=NULL;
PyThreadState*ts=_PyThreadState_GET();
#endif

PyContext*ctx=context_get();
if (ctx==NULL) {
return-1;
 }

PyHamtObject*new_vars=_PyHamt_Assoc(
ctx->ctx_vars, (PyObject*)var, val);
if (new_vars==NULL) {
return-1;
 }

Py_SETREF(ctx->ctx_vars, new_vars);

#ifndefPy_GIL_DISABLED
var->var_cached=val; /* borrow */
var->var_cached_tsid=ts->id;
var->var_cached_tsver=ts->context_ver;
#endif
return0;
}

staticint
contextvar_del(PyContextVar*var)
{
#ifndefPy_GIL_DISABLED
var->var_cached=NULL;
#endif

PyContext*ctx=context_get();
if (ctx==NULL) {
return-1;
 }

PyHamtObject*vars=ctx->ctx_vars;
PyHamtObject*new_vars=_PyHamt_Without(vars, (PyObject*)var);
if (new_vars==NULL) {
return-1;
 }

if (vars==new_vars) {
Py_DECREF(new_vars);
PyErr_SetObject(PyExc_LookupError, (PyObject*)var);
return-1;
 }

Py_SETREF(ctx->ctx_vars, new_vars);
return0;
}

staticPy_hash_t
contextvar_generate_hash(void*addr, PyObject*name)
{
/* Take hash of `name` and XOR it with the object's addr.

 The structure of the tree is encoded in objects' hashes, which
 means that sufficiently similar hashes would result in tall trees
 with many Collision nodes. Which would, in turn, result in slower
 get and set operations.

 The XORing helps to ensure that:

 (1) sequentially allocated ContextVar objects have
 different hashes;

 (2) context variables with equal names have
 different hashes.
 */

Py_hash_tname_hash=PyObject_Hash(name);
if (name_hash==-1) {
return-1;
 }

Py_hash_tres=_Py_HashPointer(addr) ^ name_hash;
returnres==-1 ? -2 : res;
}

staticPyContextVar*
contextvar_new(PyObject*name, PyObject*def)
{
if (!PyUnicode_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"context variable name must be a str");
returnNULL;
 }

PyContextVar*var=PyObject_GC_New(PyContextVar, &PyContextVar_Type);
if (var==NULL) {
returnNULL;
 }

var->var_name=Py_NewRef(name);
var->var_default=Py_XNewRef(def);

#ifndefPy_GIL_DISABLED
var->var_cached=NULL;
var->var_cached_tsid=0;
var->var_cached_tsver=0;
#endif

var->var_hash=contextvar_generate_hash(var, name);
if (var->var_hash==-1) {
Py_DECREF(var);
returnNULL;
 }

if (_PyObject_GC_MAY_BE_TRACKED(name) ||
 (def!=NULL&&_PyObject_GC_MAY_BE_TRACKED(def)))
 {
PyObject_GC_Track(var);
 }
returnvar;
}


/*[clinic input]
class _contextvars.ContextVar "PyContextVar *" "&PyContextVar_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=445da935fa8883c3]*/


staticPyObject*
contextvar_tp_new(PyTypeObject*type, PyObject*args, PyObject*kwds)
{
staticchar*kwlist[] = {"", "default", NULL};
PyObject*name;
PyObject*def=NULL;

if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O|$O:ContextVar", kwlist, &name, &def))
 {
returnNULL;
 }

return (PyObject*)contextvar_new(name, def);
}

staticint
contextvar_tp_clear(PyContextVar*self)
{
Py_CLEAR(self->var_name);
Py_CLEAR(self->var_default);
#ifndefPy_GIL_DISABLED
self->var_cached=NULL;
self->var_cached_tsid=0;
self->var_cached_tsver=0;
#endif
return0;
}

staticint
contextvar_tp_traverse(PyContextVar*self, visitprocvisit, void*arg)
{
Py_VISIT(self->var_name);
Py_VISIT(self->var_default);
return0;
}

staticvoid
contextvar_tp_dealloc(PyContextVar*self)
{
PyObject_GC_UnTrack(self);
 (void)contextvar_tp_clear(self);
Py_TYPE(self)->tp_free(self);
}

staticPy_hash_t
contextvar_tp_hash(PyContextVar*self)
{
returnself->var_hash;
}

staticPyObject*
contextvar_tp_repr(PyContextVar*self)
{
_PyUnicodeWriterwriter;

_PyUnicodeWriter_Init(&writer);

if (_PyUnicodeWriter_WriteASCIIString(
&writer, "<ContextVar name=", 17) <0)
 {
 goto error;
 }

PyObject*name=PyObject_Repr(self->var_name);
if (name==NULL) {
 goto error;
 }
if (_PyUnicodeWriter_WriteStr(&writer, name) <0) {
Py_DECREF(name);
 goto error;
 }
Py_DECREF(name);

if (self->var_default!=NULL) {
if (_PyUnicodeWriter_WriteASCIIString(&writer, " default=", 9) <0) {
 goto error;
 }

PyObject*def=PyObject_Repr(self->var_default);
if (def==NULL) {
 goto error;
 }
if (_PyUnicodeWriter_WriteStr(&writer, def) <0) {
Py_DECREF(def);
 goto error;
 }
Py_DECREF(def);
 }

PyObject*addr=PyUnicode_FromFormat(" at %p>", self);
if (addr==NULL) {
 goto error;
 }
if (_PyUnicodeWriter_WriteStr(&writer, addr) <0) {
Py_DECREF(addr);
 goto error;
 }
Py_DECREF(addr);

return_PyUnicodeWriter_Finish(&writer);

error:
_PyUnicodeWriter_Dealloc(&writer);
returnNULL;
}


/*[clinic input]
_contextvars.ContextVar.get
 default: object = NULL
 /

Return a value for the context variable for the current context.

If there is no value for the variable in the current context, the method will:
 * return the value of the default argument of the method, if provided; or
 * return the default value for the context variable, if it was created
 with one; or
 * raise a LookupError.
[clinic start generated code]*/

staticPyObject*
_contextvars_ContextVar_get_impl(PyContextVar*self, PyObject*default_value)
/*[clinic end generated code: output=0746bd0aa2ced7bf input=30aa2ab9e433e401]*/
{
if (!PyContextVar_CheckExact(self)) {
PyErr_SetString(
PyExc_TypeError, "an instance of ContextVar was expected");
returnNULL;
 }

PyObject*val;
if (PyContextVar_Get((PyObject*)self, default_value, &val) <0) {
returnNULL;
 }

if (val==NULL) {
PyErr_SetObject(PyExc_LookupError, (PyObject*)self);
returnNULL;
 }

returnval;
}