1#ifndef Py_CPYTHON_OBJECT_H
2# error "this header file must not be included directly"
3#endif
4
5PyAPI_FUNC(void) _Py_NewReference(PyObject *op);
6PyAPI_FUNC(void) _Py_NewReferenceNoTotal(PyObject *op);
7
8#ifdef Py_TRACE_REFS
9/* Py_TRACE_REFS is such major surgery that we call external routines. */
10PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);
11#endif
12
13#ifdef Py_REF_DEBUG
14/* These are useful as debugging aids when chasing down refleaks. */
15PyAPI_FUNC(Py_ssize_t) _Py_GetGlobalRefTotal(void);
16# define _Py_GetRefTotal() _Py_GetGlobalRefTotal()
17PyAPI_FUNC(Py_ssize_t) _Py_GetLegacyRefTotal(void);
18PyAPI_FUNC(Py_ssize_t) _PyInterpreterState_GetRefTotal(PyInterpreterState *);
19#endif
20
21
22/********************* String Literals ****************************************/
23/* This structure helps managing static strings. The basic usage goes like this:
24 Instead of doing
25
26 r = PyObject_CallMethod(o, "foo", "args", ...);
27
28 do
29
30 _Py_IDENTIFIER(foo);
31 ...
32 r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);
33
34 PyId_foo is a static variable, either on block level or file level. On first
35 usage, the string "foo" is interned, and the structures are linked. On interpreter
36 shutdown, all strings are released.
37
38 Alternatively, _Py_static_string allows choosing the variable name.
39 _PyUnicode_FromId returns a borrowed reference to the interned string.
40 _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.
41*/
42typedef struct _Py_Identifier {
43 const char* string;
44 // Index in PyInterpreterState.unicode.ids.array. It is process-wide
45 // unique and must be initialized to -1.
46 Py_ssize_t index;
47} _Py_Identifier;
48
49#ifndef Py_BUILD_CORE
50// For now we are keeping _Py_IDENTIFIER for continued use
51// in non-builtin extensions (and naughty PyPI modules).
52
53#define _Py_static_string_init(value) { .string = (value), .index = -1 }
54#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value)
55#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)
56
57#endif /* !Py_BUILD_CORE */
58
59typedef struct {
60 /* Number implementations must check *both*
61 arguments for proper type and implement the necessary conversions
62 in the slot functions themselves. */
63
64 binaryfunc nb_add;
65 binaryfunc nb_subtract;
66 binaryfunc nb_multiply;
67 binaryfunc nb_remainder;
68 binaryfunc nb_divmod;
69 ternaryfunc nb_power;
70 unaryfunc nb_negative;
71 unaryfunc nb_positive;
72 unaryfunc nb_absolute;
73 inquiry nb_bool;
74 unaryfunc nb_invert;
75 binaryfunc nb_lshift;
76 binaryfunc nb_rshift;
77 binaryfunc nb_and;
78 binaryfunc nb_xor;
79 binaryfunc nb_or;
80 unaryfunc nb_int;
81 void *nb_reserved; /* the slot formerly known as nb_long */
82 unaryfunc nb_float;
83
84 binaryfunc nb_inplace_add;
85 binaryfunc nb_inplace_subtract;
86 binaryfunc nb_inplace_multiply;
87 binaryfunc nb_inplace_remainder;
88 ternaryfunc nb_inplace_power;
89 binaryfunc nb_inplace_lshift;
90 binaryfunc nb_inplace_rshift;
91 binaryfunc nb_inplace_and;
92 binaryfunc nb_inplace_xor;
93 binaryfunc nb_inplace_or;
94
95 binaryfunc nb_floor_divide;
96 binaryfunc nb_true_divide;
97 binaryfunc nb_inplace_floor_divide;
98 binaryfunc nb_inplace_true_divide;
99
100 unaryfunc nb_index;
101
102 binaryfunc nb_matrix_multiply;
103 binaryfunc nb_inplace_matrix_multiply;
104} PyNumberMethods;
105
106typedef struct {
107 lenfunc sq_length;
108 binaryfunc sq_concat;
109 ssizeargfunc sq_repeat;
110 ssizeargfunc sq_item;
111 void *was_sq_slice;
112 ssizeobjargproc sq_ass_item;
113 void *was_sq_ass_slice;
114 objobjproc sq_contains;
115
116 binaryfunc sq_inplace_concat;
117 ssizeargfunc sq_inplace_repeat;
118} PySequenceMethods;
119
120typedef struct {
121 lenfunc mp_length;
122 binaryfunc mp_subscript;
123 objobjargproc mp_ass_subscript;
124} PyMappingMethods;
125
126typedef PySendResult (*sendfunc)(PyObject *iter, PyObject *value, PyObject **result);
127
128typedef struct {
129 unaryfunc am_await;
130 unaryfunc am_aiter;
131 unaryfunc am_anext;
132 sendfunc am_send;
133} PyAsyncMethods;
134
135typedef struct {
136 getbufferproc bf_getbuffer;
137 releasebufferproc bf_releasebuffer;
138} PyBufferProcs;
139
140/* Allow printfunc in the tp_vectorcall_offset slot for
141 * backwards-compatibility */
142typedef Py_ssize_t printfunc;
143
144// If this structure is modified, Doc/includes/typestruct.h should be updated
145// as well.
146struct _typeobject {
147 PyObject_VAR_HEAD
148 const char *tp_name; /* For printing, in format "<module>.<name>" */
149 Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
150
151 /* Methods to implement standard operations */
152
153 destructor tp_dealloc;
154 Py_ssize_t tp_vectorcall_offset;
155 getattrfunc tp_getattr;
156 setattrfunc tp_setattr;
157 PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
158 or tp_reserved (Python 3) */
159 reprfunc tp_repr;
160
161 /* Method suites for standard classes */
162
163 PyNumberMethods *tp_as_number;
164 PySequenceMethods *tp_as_sequence;
165 PyMappingMethods *tp_as_mapping;
166
167 /* More standard operations (here for binary compatibility) */
168
169 hashfunc tp_hash;
170 ternaryfunc tp_call;
171 reprfunc tp_str;
172 getattrofunc tp_getattro;
173 setattrofunc tp_setattro;
174
175 /* Functions to access object as input/output buffer */
176 PyBufferProcs *tp_as_buffer;
177
178 /* Flags to define presence of optional/expanded features */
179 unsigned long tp_flags;
180
181 const char *tp_doc; /* Documentation string */
182
183 /* Assigned meaning in release 2.0 */
184 /* call function for all accessible objects */
185 traverseproc tp_traverse;
186
187 /* delete references to contained objects */
188 inquiry tp_clear;
189
190 /* Assigned meaning in release 2.1 */
191 /* rich comparisons */
192 richcmpfunc tp_richcompare;
193
194 /* weak reference enabler */
195 Py_ssize_t tp_weaklistoffset;
196
197 /* Iterators */
198 getiterfunc tp_iter;
199 iternextfunc tp_iternext;
200
201 /* Attribute descriptor and subclassing stuff */
202 PyMethodDef *tp_methods;
203 PyMemberDef *tp_members;
204 PyGetSetDef *tp_getset;
205 // Strong reference on a heap type, borrowed reference on a static type
206 PyTypeObject *tp_base;
207 PyObject *tp_dict;
208 descrgetfunc tp_descr_get;
209 descrsetfunc tp_descr_set;
210 Py_ssize_t tp_dictoffset;
211 initproc tp_init;
212 allocfunc tp_alloc;
213 newfunc tp_new;
214 freefunc tp_free; /* Low-level free-memory routine */
215 inquiry tp_is_gc; /* For PyObject_IS_GC */
216 PyObject *tp_bases;
217 PyObject *tp_mro; /* method resolution order */
218 PyObject *tp_cache; /* no longer used */
219 void *tp_subclasses; /* for static builtin types this is an index */
220 PyObject *tp_weaklist; /* not used for static builtin types */
221 destructor tp_del;
222
223 /* Type attribute cache version tag. Added in version 2.6 */
224 unsigned int tp_version_tag;
225
226 destructor tp_finalize;
227 vectorcallfunc tp_vectorcall;
228
229 /* bitset of which type-watchers care about this type */
230 unsigned char tp_watched;
231};
232
233/* This struct is used by the specializer
234 * It should should be treated as an opaque blob
235 * by code other than the specializer and interpreter. */
236struct _specialization_cache {
237 // In order to avoid bloating the bytecode with lots of inline caches, the
238 // members of this structure have a somewhat unique contract. They are set
239 // by the specialization machinery, and are invalidated by PyType_Modified.
240 // The rules for using them are as follows:
241 // - If getitem is non-NULL, then it is the same Python function that
242 // PyType_Lookup(cls, "__getitem__") would return.
243 // - If getitem is NULL, then getitem_version is meaningless.
244 // - If getitem->func_version == getitem_version, then getitem can be called
245 // with two positional arguments and no keyword arguments, and has neither
246 // *args nor **kwargs (as required by BINARY_SUBSCR_GETITEM):
247 PyObject *getitem;
248 uint32_t getitem_version;
249};
250
251/* The *real* layout of a type object when allocated on the heap */
252typedef struct _heaptypeobject {
253 /* Note: there's a dependency on the order of these members
254 in slotptr() in typeobject.c . */
255 PyTypeObject ht_type;
256 PyAsyncMethods as_async;
257 PyNumberMethods as_number;
258 PyMappingMethods as_mapping;
259 PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
260 so that the mapping wins when both
261 the mapping and the sequence define
262 a given operator (e.g. __getitem__).
263 see add_operators() in typeobject.c . */
264 PyBufferProcs as_buffer;
265 PyObject *ht_name, *ht_slots, *ht_qualname;
266 struct _dictkeysobject *ht_cached_keys;
267 PyObject *ht_module;
268 char *_ht_tpname; // Storage for "tp_name"; see PyType_FromModuleAndSpec
269 struct _specialization_cache _spec_cache; // For use by the specializer.
270 /* here are optional user slots, followed by the members. */
271} PyHeapTypeObject;
272
273PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *);
274PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
275PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);
276PyAPI_FUNC(PyObject *) _PyObject_LookupSpecialId(PyObject *, _Py_Identifier *);
277#ifndef Py_BUILD_CORE
278// Backward compatibility for 3rd-party extensions
279// that may be using the old name.
280#define _PyObject_LookupSpecial _PyObject_LookupSpecialId
281#endif
282PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);
283PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);
284PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);
285PyAPI_FUNC(PyObject *) PyType_GetModuleByDef(PyTypeObject *, PyModuleDef *);
286PyAPI_FUNC(PyObject *) PyType_GetDict(PyTypeObject *);
287
288PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);
289PyAPI_FUNC(void) _Py_BreakPoint(void);
290PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
291PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *);
292
293PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);
294PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, _Py_Identifier *);
295PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, _Py_Identifier *, PyObject *);
296/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which
297 don't raise AttributeError.
298
299 Return 1 and set *result != NULL if an attribute is found.
300 Return 0 and set *result == NULL if an attribute is not found;
301 an AttributeError is silenced.
302 Return -1 and set *result == NULL if an error other than AttributeError
303 is raised.
304*/
305PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **);
306PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, _Py_Identifier *, PyObject **);
307
308PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
309
310PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);
311PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
312PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);
313PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);
314
315/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
316 dict as the last parameter. */
317PyAPI_FUNC(PyObject *)
318_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int);
319PyAPI_FUNC(int)
320_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,
321 PyObject *, PyObject *);
322
323PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *);
324
325/* Safely decref `dst` and set `dst` to `src`.
326 *
327 * As in case of Py_CLEAR "the obvious" code can be deadly:
328 *
329 * Py_DECREF(dst);
330 * dst = src;
331 *
332 * The safe way is:
333 *
334 * Py_SETREF(dst, src);
335 *
336 * That arranges to set `dst` to `src` _before_ decref'ing, so that any code
337 * triggered as a side-effect of `dst` getting torn down no longer believes
338 * `dst` points to a valid object.
339 *
340 * Temporary variables are used to only evalutate macro arguments once and so
341 * avoid the duplication of side effects. _Py_TYPEOF() or memcpy() is used to
342 * avoid a miscompilation caused by type punning. See Py_CLEAR() comment for
343 * implementation details about type punning.
344 *
345 * The memcpy() implementation does not emit a compiler warning if 'src' has
346 * not the same type than 'src': any pointer type is accepted for 'src'.
347 */
348#ifdef _Py_TYPEOF
349#define Py_SETREF(dst, src) \
350 do { \
351 _Py_TYPEOF(dst)* _tmp_dst_ptr = &(dst); \
352 _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr); \
353 *_tmp_dst_ptr = (src); \
354 Py_DECREF(_tmp_old_dst); \
355 } while (0)
356#else
357#define Py_SETREF(dst, src) \
358 do { \
359 PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
360 PyObject *_tmp_old_dst = (*_tmp_dst_ptr); \
361 PyObject *_tmp_src = _PyObject_CAST(src); \
362 memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject*)); \
363 Py_DECREF(_tmp_old_dst); \
364 } while (0)
365#endif
366
367/* Py_XSETREF() is a variant of Py_SETREF() that uses Py_XDECREF() instead of
368 * Py_DECREF().
369 */
370#ifdef _Py_TYPEOF
371#define Py_XSETREF(dst, src) \
372 do { \
373 _Py_TYPEOF(dst)* _tmp_dst_ptr = &(dst); \
374 _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr); \
375 *_tmp_dst_ptr = (src); \
376 Py_XDECREF(_tmp_old_dst); \
377 } while (0)
378#else
379#define Py_XSETREF(dst, src) \
380 do { \
381 PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
382 PyObject *_tmp_old_dst = (*_tmp_dst_ptr); \
383 PyObject *_tmp_src = _PyObject_CAST(src); \
384 memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject*)); \
385 Py_XDECREF(_tmp_old_dst); \
386 } while (0)
387#endif
388
389
390PyAPI_DATA(PyTypeObject) _PyNone_Type;
391PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;
392
393/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.
394 * Defined in object.c.
395 */
396PyAPI_DATA(int) _Py_SwappedOp[];
397
398PyAPI_FUNC(void)
399_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
400 size_t sizeof_block);
401PyAPI_FUNC(void)
402_PyObject_DebugTypeStats(FILE *out);
403
404/* Define a pair of assertion macros:
405 _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT().
406
407 These work like the regular C assert(), in that they will abort the
408 process with a message on stderr if the given condition fails to hold,
409 but compile away to nothing if NDEBUG is defined.
410
411 However, before aborting, Python will also try to call _PyObject_Dump() on
412 the given object. This may be of use when investigating bugs in which a
413 particular object is corrupt (e.g. buggy a tp_visit method in an extension
414 module breaking the garbage collector), to help locate the broken objects.
415
416 The WITH_MSG variant allows you to supply an additional message that Python
417 will attempt to print to stderr, after the object dump. */
418#ifdef NDEBUG
419 /* No debugging: compile away the assertions: */
420# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
421 ((void)0)
422#else
423 /* With debugging: generate checks: */
424# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
425 ((expr) \
426 ? (void)(0) \
427 : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \
428 (msg), (filename), (lineno), (func)))
429#endif
430
431#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \
432 _PyObject_ASSERT_FROM((obj), expr, (msg), __FILE__, __LINE__, __func__)
433#define _PyObject_ASSERT(obj, expr) \
434 _PyObject_ASSERT_WITH_MSG((obj), expr, NULL)
435
436#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \
437 _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__)
438
439/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined,
440 to avoid causing compiler/linker errors when building extensions without
441 NDEBUG against a Python built with NDEBUG defined.
442
443 msg, expr and function can be NULL. */
444PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed(
445 PyObject *obj,
446 const char *expr,
447 const char *msg,
448 const char *file,
449 int line,
450 const char *function);
451
452/* Check if an object is consistent. For example, ensure that the reference
453 counter is greater than or equal to 1, and ensure that ob_type is not NULL.
454
455 Call _PyObject_AssertFailed() if the object is inconsistent.
456
457 If check_content is zero, only check header fields: reduce the overhead.
458
459 The function always return 1. The return value is just here to be able to
460 write:
461
462 assert(_PyObject_CheckConsistency(obj, 1)); */
463PyAPI_FUNC(int) _PyObject_CheckConsistency(
464 PyObject *op,
465 int check_content);
466
467
468/* Trashcan mechanism, thanks to Christian Tismer.
469
470When deallocating a container object, it's possible to trigger an unbounded
471chain of deallocations, as each Py_DECREF in turn drops the refcount on "the
472next" object in the chain to 0. This can easily lead to stack overflows,
473especially in threads (which typically have less stack space to work with).
474
475A container object can avoid this by bracketing the body of its tp_dealloc
476function with a pair of macros:
477
478static void
479mytype_dealloc(mytype *p)
480{
481 ... declarations go here ...
482
483 PyObject_GC_UnTrack(p); // must untrack first
484 Py_TRASHCAN_BEGIN(p, mytype_dealloc)
485 ... The body of the deallocator goes here, including all calls ...
486 ... to Py_DECREF on contained objects. ...
487 Py_TRASHCAN_END // there should be no code after this
488}
489
490CAUTION: Never return from the middle of the body! If the body needs to
491"get out early", put a label immediately before the Py_TRASHCAN_END
492call, and goto it. Else the call-depth counter (see below) will stay
493above 0 forever, and the trashcan will never get emptied.
494
495How it works: The BEGIN macro increments a call-depth counter. So long
496as this counter is small, the body of the deallocator is run directly without
497further ado. But if the counter gets large, it instead adds p to a list of
498objects to be deallocated later, skips the body of the deallocator, and
499resumes execution after the END macro. The tp_dealloc routine then returns
500without deallocating anything (and so unbounded call-stack depth is avoided).
501
502When the call stack finishes unwinding again, code generated by the END macro
503notices this, and calls another routine to deallocate all the objects that
504may have been added to the list of deferred deallocations. In effect, a
505chain of N deallocations is broken into (N-1)/(_PyTrash_UNWIND_LEVEL-1) pieces,
506with the call stack never exceeding a depth of _PyTrash_UNWIND_LEVEL.
507
508Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base
509class, we need to ensure that the trashcan is only triggered on the tp_dealloc
510of the actual class being deallocated. Otherwise we might end up with a
511partially-deallocated object. To check this, the tp_dealloc function must be
512passed as second argument to Py_TRASHCAN_BEGIN().
513*/
514
515/* Python 3.9 private API, invoked by the macros below. */
516PyAPI_FUNC(int) _PyTrash_begin(PyThreadState *tstate, PyObject *op);
517PyAPI_FUNC(void) _PyTrash_end(PyThreadState *tstate);
518/* Python 3.10 private API, invoked by the Py_TRASHCAN_BEGIN(). */
519PyAPI_FUNC(int) _PyTrash_cond(PyObject *op, destructor dealloc);
520
521#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \
522 do { \
523 PyThreadState *_tstate = NULL; \
524 /* If "cond" is false, then _tstate remains NULL and the deallocator \
525 * is run normally without involving the trashcan */ \
526 if (cond) { \
527 _tstate = _PyThreadState_UncheckedGet(); \
528 if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \
529 break; \
530 } \
531 }
532 /* The body of the deallocator is here. */
533#define Py_TRASHCAN_END \
534 if (_tstate) { \
535 _PyTrash_end(_tstate); \
536 } \
537 } while (0);
538
539#define Py_TRASHCAN_BEGIN(op, dealloc) \
540 Py_TRASHCAN_BEGIN_CONDITION((op), \
541 _PyTrash_cond(_PyObject_CAST(op), (destructor)(dealloc)))
542
543/* The following two macros, Py_TRASHCAN_SAFE_BEGIN and
544 * Py_TRASHCAN_SAFE_END, are deprecated since version 3.11 and
545 * will be removed in the future.
546 * Use Py_TRASHCAN_BEGIN and Py_TRASHCAN_END instead.
547 */
548Py_DEPRECATED(3.11) typedef int UsingDeprecatedTrashcanMacro;
549#define Py_TRASHCAN_SAFE_BEGIN(op) \
550 do { \
551 UsingDeprecatedTrashcanMacro cond=1; \
552 Py_TRASHCAN_BEGIN_CONDITION((op), cond);
553#define Py_TRASHCAN_SAFE_END(op) \
554 Py_TRASHCAN_END; \
555 } while(0);
556
557PyAPI_FUNC(void *) PyObject_GetItemData(PyObject *obj);
558
559PyAPI_FUNC(int) _PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg);
560PyAPI_FUNC(void) _PyObject_ClearManagedDict(PyObject *obj);
561
562#define TYPE_MAX_WATCHERS 8
563
564typedef int(*PyType_WatchCallback)(PyTypeObject *);
565PyAPI_FUNC(int) PyType_AddWatcher(PyType_WatchCallback callback);
566PyAPI_FUNC(int) PyType_ClearWatcher(int watcher_id);
567PyAPI_FUNC(int) PyType_Watch(int watcher_id, PyObject *type);
568PyAPI_FUNC(int) PyType_Unwatch(int watcher_id, PyObject *type);
569
570/* Attempt to assign a version tag to the given type.
571 *
572 * Returns 1 if the type already had a valid version tag or a new one was
573 * assigned, or 0 if a new tag could not be assigned.
574 */
575PyAPI_FUNC(int) PyUnstable_Type_AssignVersionTag(PyTypeObject *type);
576

source code of include/python3.12/cpython/object.h