1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 # include "pycore_gc.h" // PyGC_Head
7 # include "pycore_runtime.h" // _Py_ID()
8 #endif
9 #include "pycore_modsupport.h" // _PyArg_CheckPositional()
10
11 PyDoc_STRVAR(_imp_lock_held__doc__,
12 "lock_held($module, /)\n"
13 "--\n"
14 "\n"
15 "Return True if the import lock is currently held, else False.\n"
16 "\n"
17 "On platforms without threads, return False.");
18
19 #define _IMP_LOCK_HELD_METHODDEF \
20 {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__},
21
22 static PyObject *
23 _imp_lock_held_impl(PyObject *module);
24
25 static PyObject *
_imp_lock_held(PyObject * module,PyObject * Py_UNUSED (ignored))26 _imp_lock_held(PyObject *module, PyObject *Py_UNUSED(ignored))
27 {
28 return _imp_lock_held_impl(module);
29 }
30
31 PyDoc_STRVAR(_imp_acquire_lock__doc__,
32 "acquire_lock($module, /)\n"
33 "--\n"
34 "\n"
35 "Acquires the interpreter\'s import lock for the current thread.\n"
36 "\n"
37 "This lock should be used by import hooks to ensure thread-safety when importing\n"
38 "modules. On platforms without threads, this function does nothing.");
39
40 #define _IMP_ACQUIRE_LOCK_METHODDEF \
41 {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__},
42
43 static PyObject *
44 _imp_acquire_lock_impl(PyObject *module);
45
46 static PyObject *
_imp_acquire_lock(PyObject * module,PyObject * Py_UNUSED (ignored))47 _imp_acquire_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
48 {
49 return _imp_acquire_lock_impl(module);
50 }
51
52 PyDoc_STRVAR(_imp_release_lock__doc__,
53 "release_lock($module, /)\n"
54 "--\n"
55 "\n"
56 "Release the interpreter\'s import lock.\n"
57 "\n"
58 "On platforms without threads, this function does nothing.");
59
60 #define _IMP_RELEASE_LOCK_METHODDEF \
61 {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__},
62
63 static PyObject *
64 _imp_release_lock_impl(PyObject *module);
65
66 static PyObject *
_imp_release_lock(PyObject * module,PyObject * Py_UNUSED (ignored))67 _imp_release_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
68 {
69 return _imp_release_lock_impl(module);
70 }
71
72 PyDoc_STRVAR(_imp__fix_co_filename__doc__,
73 "_fix_co_filename($module, code, path, /)\n"
74 "--\n"
75 "\n"
76 "Changes code.co_filename to specify the passed-in file path.\n"
77 "\n"
78 " code\n"
79 " Code object to change.\n"
80 " path\n"
81 " File path to use.");
82
83 #define _IMP__FIX_CO_FILENAME_METHODDEF \
84 {"_fix_co_filename", _PyCFunction_CAST(_imp__fix_co_filename), METH_FASTCALL, _imp__fix_co_filename__doc__},
85
86 static PyObject *
87 _imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
88 PyObject *path);
89
90 static PyObject *
_imp__fix_co_filename(PyObject * module,PyObject * const * args,Py_ssize_t nargs)91 _imp__fix_co_filename(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
92 {
93 PyObject *return_value = NULL;
94 PyCodeObject *code;
95 PyObject *path;
96
97 if (!_PyArg_CheckPositional("_fix_co_filename", nargs, 2, 2)) {
98 goto exit;
99 }
100 if (!PyObject_TypeCheck(args[0], &PyCode_Type)) {
101 _PyArg_BadArgument("_fix_co_filename", "argument 1", (&PyCode_Type)->tp_name, args[0]);
102 goto exit;
103 }
104 code = (PyCodeObject *)args[0];
105 if (!PyUnicode_Check(args[1])) {
106 _PyArg_BadArgument("_fix_co_filename", "argument 2", "str", args[1]);
107 goto exit;
108 }
109 path = args[1];
110 return_value = _imp__fix_co_filename_impl(module, code, path);
111
112 exit:
113 return return_value;
114 }
115
116 PyDoc_STRVAR(_imp_create_builtin__doc__,
117 "create_builtin($module, spec, /)\n"
118 "--\n"
119 "\n"
120 "Create an extension module.");
121
122 #define _IMP_CREATE_BUILTIN_METHODDEF \
123 {"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, _imp_create_builtin__doc__},
124
125 PyDoc_STRVAR(_imp_extension_suffixes__doc__,
126 "extension_suffixes($module, /)\n"
127 "--\n"
128 "\n"
129 "Returns the list of file suffixes used to identify extension modules.");
130
131 #define _IMP_EXTENSION_SUFFIXES_METHODDEF \
132 {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__},
133
134 static PyObject *
135 _imp_extension_suffixes_impl(PyObject *module);
136
137 static PyObject *
_imp_extension_suffixes(PyObject * module,PyObject * Py_UNUSED (ignored))138 _imp_extension_suffixes(PyObject *module, PyObject *Py_UNUSED(ignored))
139 {
140 return _imp_extension_suffixes_impl(module);
141 }
142
143 PyDoc_STRVAR(_imp_init_frozen__doc__,
144 "init_frozen($module, name, /)\n"
145 "--\n"
146 "\n"
147 "Initializes a frozen module.");
148
149 #define _IMP_INIT_FROZEN_METHODDEF \
150 {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__},
151
152 static PyObject *
153 _imp_init_frozen_impl(PyObject *module, PyObject *name);
154
155 static PyObject *
_imp_init_frozen(PyObject * module,PyObject * arg)156 _imp_init_frozen(PyObject *module, PyObject *arg)
157 {
158 PyObject *return_value = NULL;
159 PyObject *name;
160
161 if (!PyUnicode_Check(arg)) {
162 _PyArg_BadArgument("init_frozen", "argument", "str", arg);
163 goto exit;
164 }
165 name = arg;
166 return_value = _imp_init_frozen_impl(module, name);
167
168 exit:
169 return return_value;
170 }
171
172 PyDoc_STRVAR(_imp_find_frozen__doc__,
173 "find_frozen($module, name, /, *, withdata=False)\n"
174 "--\n"
175 "\n"
176 "Return info about the corresponding frozen module (if there is one) or None.\n"
177 "\n"
178 "The returned info (a 2-tuple):\n"
179 "\n"
180 " * data the raw marshalled bytes\n"
181 " * is_package whether or not it is a package\n"
182 " * origname the originally frozen module\'s name, or None if not\n"
183 " a stdlib module (this will usually be the same as\n"
184 " the module\'s current name)");
185
186 #define _IMP_FIND_FROZEN_METHODDEF \
187 {"find_frozen", _PyCFunction_CAST(_imp_find_frozen), METH_FASTCALL|METH_KEYWORDS, _imp_find_frozen__doc__},
188
189 static PyObject *
190 _imp_find_frozen_impl(PyObject *module, PyObject *name, int withdata);
191
192 static PyObject *
_imp_find_frozen(PyObject * module,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)193 _imp_find_frozen(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
194 {
195 PyObject *return_value = NULL;
196 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
197
198 #define NUM_KEYWORDS 1
199 static struct {
200 PyGC_Head _this_is_not_used;
201 PyObject_VAR_HEAD
202 PyObject *ob_item[NUM_KEYWORDS];
203 } _kwtuple = {
204 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
205 .ob_item = { &_Py_ID(withdata), },
206 };
207 #undef NUM_KEYWORDS
208 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
209
210 #else // !Py_BUILD_CORE
211 # define KWTUPLE NULL
212 #endif // !Py_BUILD_CORE
213
214 static const char * const _keywords[] = {"", "withdata", NULL};
215 static _PyArg_Parser _parser = {
216 .keywords = _keywords,
217 .fname = "find_frozen",
218 .kwtuple = KWTUPLE,
219 };
220 #undef KWTUPLE
221 PyObject *argsbuf[2];
222 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
223 PyObject *name;
224 int withdata = 0;
225
226 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
227 if (!args) {
228 goto exit;
229 }
230 if (!PyUnicode_Check(args[0])) {
231 _PyArg_BadArgument("find_frozen", "argument 1", "str", args[0]);
232 goto exit;
233 }
234 name = args[0];
235 if (!noptargs) {
236 goto skip_optional_kwonly;
237 }
238 withdata = PyObject_IsTrue(args[1]);
239 if (withdata < 0) {
240 goto exit;
241 }
242 skip_optional_kwonly:
243 return_value = _imp_find_frozen_impl(module, name, withdata);
244
245 exit:
246 return return_value;
247 }
248
249 PyDoc_STRVAR(_imp_get_frozen_object__doc__,
250 "get_frozen_object($module, name, data=None, /)\n"
251 "--\n"
252 "\n"
253 "Create a code object for a frozen module.");
254
255 #define _IMP_GET_FROZEN_OBJECT_METHODDEF \
256 {"get_frozen_object", _PyCFunction_CAST(_imp_get_frozen_object), METH_FASTCALL, _imp_get_frozen_object__doc__},
257
258 static PyObject *
259 _imp_get_frozen_object_impl(PyObject *module, PyObject *name,
260 PyObject *dataobj);
261
262 static PyObject *
_imp_get_frozen_object(PyObject * module,PyObject * const * args,Py_ssize_t nargs)263 _imp_get_frozen_object(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
264 {
265 PyObject *return_value = NULL;
266 PyObject *name;
267 PyObject *dataobj = Py_None;
268
269 if (!_PyArg_CheckPositional("get_frozen_object", nargs, 1, 2)) {
270 goto exit;
271 }
272 if (!PyUnicode_Check(args[0])) {
273 _PyArg_BadArgument("get_frozen_object", "argument 1", "str", args[0]);
274 goto exit;
275 }
276 name = args[0];
277 if (nargs < 2) {
278 goto skip_optional;
279 }
280 dataobj = args[1];
281 skip_optional:
282 return_value = _imp_get_frozen_object_impl(module, name, dataobj);
283
284 exit:
285 return return_value;
286 }
287
288 PyDoc_STRVAR(_imp_is_frozen_package__doc__,
289 "is_frozen_package($module, name, /)\n"
290 "--\n"
291 "\n"
292 "Returns True if the module name is of a frozen package.");
293
294 #define _IMP_IS_FROZEN_PACKAGE_METHODDEF \
295 {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__},
296
297 static PyObject *
298 _imp_is_frozen_package_impl(PyObject *module, PyObject *name);
299
300 static PyObject *
_imp_is_frozen_package(PyObject * module,PyObject * arg)301 _imp_is_frozen_package(PyObject *module, PyObject *arg)
302 {
303 PyObject *return_value = NULL;
304 PyObject *name;
305
306 if (!PyUnicode_Check(arg)) {
307 _PyArg_BadArgument("is_frozen_package", "argument", "str", arg);
308 goto exit;
309 }
310 name = arg;
311 return_value = _imp_is_frozen_package_impl(module, name);
312
313 exit:
314 return return_value;
315 }
316
317 PyDoc_STRVAR(_imp_is_builtin__doc__,
318 "is_builtin($module, name, /)\n"
319 "--\n"
320 "\n"
321 "Returns True if the module name corresponds to a built-in module.");
322
323 #define _IMP_IS_BUILTIN_METHODDEF \
324 {"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__},
325
326 static PyObject *
327 _imp_is_builtin_impl(PyObject *module, PyObject *name);
328
329 static PyObject *
_imp_is_builtin(PyObject * module,PyObject * arg)330 _imp_is_builtin(PyObject *module, PyObject *arg)
331 {
332 PyObject *return_value = NULL;
333 PyObject *name;
334
335 if (!PyUnicode_Check(arg)) {
336 _PyArg_BadArgument("is_builtin", "argument", "str", arg);
337 goto exit;
338 }
339 name = arg;
340 return_value = _imp_is_builtin_impl(module, name);
341
342 exit:
343 return return_value;
344 }
345
346 PyDoc_STRVAR(_imp_is_frozen__doc__,
347 "is_frozen($module, name, /)\n"
348 "--\n"
349 "\n"
350 "Returns True if the module name corresponds to a frozen module.");
351
352 #define _IMP_IS_FROZEN_METHODDEF \
353 {"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__},
354
355 static PyObject *
356 _imp_is_frozen_impl(PyObject *module, PyObject *name);
357
358 static PyObject *
_imp_is_frozen(PyObject * module,PyObject * arg)359 _imp_is_frozen(PyObject *module, PyObject *arg)
360 {
361 PyObject *return_value = NULL;
362 PyObject *name;
363
364 if (!PyUnicode_Check(arg)) {
365 _PyArg_BadArgument("is_frozen", "argument", "str", arg);
366 goto exit;
367 }
368 name = arg;
369 return_value = _imp_is_frozen_impl(module, name);
370
371 exit:
372 return return_value;
373 }
374
375 PyDoc_STRVAR(_imp__frozen_module_names__doc__,
376 "_frozen_module_names($module, /)\n"
377 "--\n"
378 "\n"
379 "Returns the list of available frozen modules.");
380
381 #define _IMP__FROZEN_MODULE_NAMES_METHODDEF \
382 {"_frozen_module_names", (PyCFunction)_imp__frozen_module_names, METH_NOARGS, _imp__frozen_module_names__doc__},
383
384 static PyObject *
385 _imp__frozen_module_names_impl(PyObject *module);
386
387 static PyObject *
_imp__frozen_module_names(PyObject * module,PyObject * Py_UNUSED (ignored))388 _imp__frozen_module_names(PyObject *module, PyObject *Py_UNUSED(ignored))
389 {
390 return _imp__frozen_module_names_impl(module);
391 }
392
393 PyDoc_STRVAR(_imp__override_frozen_modules_for_tests__doc__,
394 "_override_frozen_modules_for_tests($module, override, /)\n"
395 "--\n"
396 "\n"
397 "(internal-only) Override PyConfig.use_frozen_modules.\n"
398 "\n"
399 "(-1: \"off\", 1: \"on\", 0: no override)\n"
400 "See frozen_modules() in Lib/test/support/import_helper.py.");
401
402 #define _IMP__OVERRIDE_FROZEN_MODULES_FOR_TESTS_METHODDEF \
403 {"_override_frozen_modules_for_tests", (PyCFunction)_imp__override_frozen_modules_for_tests, METH_O, _imp__override_frozen_modules_for_tests__doc__},
404
405 static PyObject *
406 _imp__override_frozen_modules_for_tests_impl(PyObject *module, int override);
407
408 static PyObject *
_imp__override_frozen_modules_for_tests(PyObject * module,PyObject * arg)409 _imp__override_frozen_modules_for_tests(PyObject *module, PyObject *arg)
410 {
411 PyObject *return_value = NULL;
412 int override;
413
414 override = PyLong_AsInt(arg);
415 if (override == -1 && PyErr_Occurred()) {
416 goto exit;
417 }
418 return_value = _imp__override_frozen_modules_for_tests_impl(module, override);
419
420 exit:
421 return return_value;
422 }
423
424 PyDoc_STRVAR(_imp__override_multi_interp_extensions_check__doc__,
425 "_override_multi_interp_extensions_check($module, override, /)\n"
426 "--\n"
427 "\n"
428 "(internal-only) Override PyInterpreterConfig.check_multi_interp_extensions.\n"
429 "\n"
430 "(-1: \"never\", 1: \"always\", 0: no override)");
431
432 #define _IMP__OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK_METHODDEF \
433 {"_override_multi_interp_extensions_check", (PyCFunction)_imp__override_multi_interp_extensions_check, METH_O, _imp__override_multi_interp_extensions_check__doc__},
434
435 static PyObject *
436 _imp__override_multi_interp_extensions_check_impl(PyObject *module,
437 int override);
438
439 static PyObject *
_imp__override_multi_interp_extensions_check(PyObject * module,PyObject * arg)440 _imp__override_multi_interp_extensions_check(PyObject *module, PyObject *arg)
441 {
442 PyObject *return_value = NULL;
443 int override;
444
445 override = PyLong_AsInt(arg);
446 if (override == -1 && PyErr_Occurred()) {
447 goto exit;
448 }
449 return_value = _imp__override_multi_interp_extensions_check_impl(module, override);
450
451 exit:
452 return return_value;
453 }
454
455 #if defined(HAVE_DYNAMIC_LOADING)
456
457 PyDoc_STRVAR(_imp_create_dynamic__doc__,
458 "create_dynamic($module, spec, file=<unrepresentable>, /)\n"
459 "--\n"
460 "\n"
461 "Create an extension module.");
462
463 #define _IMP_CREATE_DYNAMIC_METHODDEF \
464 {"create_dynamic", _PyCFunction_CAST(_imp_create_dynamic), METH_FASTCALL, _imp_create_dynamic__doc__},
465
466 static PyObject *
467 _imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file);
468
469 static PyObject *
_imp_create_dynamic(PyObject * module,PyObject * const * args,Py_ssize_t nargs)470 _imp_create_dynamic(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
471 {
472 PyObject *return_value = NULL;
473 PyObject *spec;
474 PyObject *file = NULL;
475
476 if (!_PyArg_CheckPositional("create_dynamic", nargs, 1, 2)) {
477 goto exit;
478 }
479 spec = args[0];
480 if (nargs < 2) {
481 goto skip_optional;
482 }
483 file = args[1];
484 skip_optional:
485 return_value = _imp_create_dynamic_impl(module, spec, file);
486
487 exit:
488 return return_value;
489 }
490
491 #endif /* defined(HAVE_DYNAMIC_LOADING) */
492
493 #if defined(HAVE_DYNAMIC_LOADING)
494
495 PyDoc_STRVAR(_imp_exec_dynamic__doc__,
496 "exec_dynamic($module, mod, /)\n"
497 "--\n"
498 "\n"
499 "Initialize an extension module.");
500
501 #define _IMP_EXEC_DYNAMIC_METHODDEF \
502 {"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, _imp_exec_dynamic__doc__},
503
504 static int
505 _imp_exec_dynamic_impl(PyObject *module, PyObject *mod);
506
507 static PyObject *
_imp_exec_dynamic(PyObject * module,PyObject * mod)508 _imp_exec_dynamic(PyObject *module, PyObject *mod)
509 {
510 PyObject *return_value = NULL;
511 int _return_value;
512
513 _return_value = _imp_exec_dynamic_impl(module, mod);
514 if ((_return_value == -1) && PyErr_Occurred()) {
515 goto exit;
516 }
517 return_value = PyLong_FromLong((long)_return_value);
518
519 exit:
520 return return_value;
521 }
522
523 #endif /* defined(HAVE_DYNAMIC_LOADING) */
524
525 PyDoc_STRVAR(_imp_exec_builtin__doc__,
526 "exec_builtin($module, mod, /)\n"
527 "--\n"
528 "\n"
529 "Initialize a built-in module.");
530
531 #define _IMP_EXEC_BUILTIN_METHODDEF \
532 {"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, _imp_exec_builtin__doc__},
533
534 static int
535 _imp_exec_builtin_impl(PyObject *module, PyObject *mod);
536
537 static PyObject *
_imp_exec_builtin(PyObject * module,PyObject * mod)538 _imp_exec_builtin(PyObject *module, PyObject *mod)
539 {
540 PyObject *return_value = NULL;
541 int _return_value;
542
543 _return_value = _imp_exec_builtin_impl(module, mod);
544 if ((_return_value == -1) && PyErr_Occurred()) {
545 goto exit;
546 }
547 return_value = PyLong_FromLong((long)_return_value);
548
549 exit:
550 return return_value;
551 }
552
553 PyDoc_STRVAR(_imp_source_hash__doc__,
554 "source_hash($module, /, key, source)\n"
555 "--\n"
556 "\n");
557
558 #define _IMP_SOURCE_HASH_METHODDEF \
559 {"source_hash", _PyCFunction_CAST(_imp_source_hash), METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},
560
561 static PyObject *
562 _imp_source_hash_impl(PyObject *module, long key, Py_buffer *source);
563
564 static PyObject *
_imp_source_hash(PyObject * module,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)565 _imp_source_hash(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
566 {
567 PyObject *return_value = NULL;
568 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
569
570 #define NUM_KEYWORDS 2
571 static struct {
572 PyGC_Head _this_is_not_used;
573 PyObject_VAR_HEAD
574 PyObject *ob_item[NUM_KEYWORDS];
575 } _kwtuple = {
576 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
577 .ob_item = { &_Py_ID(key), &_Py_ID(source), },
578 };
579 #undef NUM_KEYWORDS
580 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
581
582 #else // !Py_BUILD_CORE
583 # define KWTUPLE NULL
584 #endif // !Py_BUILD_CORE
585
586 static const char * const _keywords[] = {"key", "source", NULL};
587 static _PyArg_Parser _parser = {
588 .keywords = _keywords,
589 .fname = "source_hash",
590 .kwtuple = KWTUPLE,
591 };
592 #undef KWTUPLE
593 PyObject *argsbuf[2];
594 long key;
595 Py_buffer source = {NULL, NULL};
596
597 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
598 if (!args) {
599 goto exit;
600 }
601 key = PyLong_AsLong(args[0]);
602 if (key == -1 && PyErr_Occurred()) {
603 goto exit;
604 }
605 if (PyObject_GetBuffer(args[1], &source, PyBUF_SIMPLE) != 0) {
606 goto exit;
607 }
608 return_value = _imp_source_hash_impl(module, key, &source);
609
610 exit:
611 /* Cleanup for source */
612 if (source.obj) {
613 PyBuffer_Release(&source);
614 }
615
616 return return_value;
617 }
618
619 #ifndef _IMP_CREATE_DYNAMIC_METHODDEF
620 #define _IMP_CREATE_DYNAMIC_METHODDEF
621 #endif /* !defined(_IMP_CREATE_DYNAMIC_METHODDEF) */
622
623 #ifndef _IMP_EXEC_DYNAMIC_METHODDEF
624 #define _IMP_EXEC_DYNAMIC_METHODDEF
625 #endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
626 /*[clinic end generated code: output=dbd63707bd40b07c input=a9049054013a1b77]*/
627